DEPS

diff --git a/DEPS b/DEPS
index 844c40e..c8f0f1a4 100644
--- a/DEPS
+++ b/DEPS
@@ -52,7 +52,7 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling ANGLE
   # and whatever else without interference from each other.
-  'angle_revision': '13c0dd4631b13c76c9d8bc8d01c5236567a57b14',
+  'angle_revision': '85d624a5101da5ed9b327dba5b8186ab25bcd9dc',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling build tools
   # and whatever else without interference from each other.
@@ -64,7 +64,7 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling PDFium
   # and whatever else without interference from each other.
-  'pdfium_revision': '073797b6cff9947070077ff4b3cccc63059dc4e5',
+  'pdfium_revision': 'd24b97ee1d065eff482355ea3ff82be59bb528b1',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling openmax_dl
   # and whatever else without interference from each other.
@@ -96,7 +96,7 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling catapult
   # and whatever else without interference from each other.
-  'catapult_revision': '1a1b45a572561a9eff29a35c9b59e2d0ff55bd4d',
+  'catapult_revision': '868342d8543e907b118cf98d1e11fba88043d36a',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling libFuzzer
   # and whatever else without interference from each other.
@@ -208,7 +208,7 @@
     Var('chromium_git') + '/external/selenium/py.git' + '@' + '5fd78261a75fe08d27ca4835fb6c5ce4b42275bd',
 
   'src/third_party/libvpx/source/libvpx':
-    Var('chromium_git') + '/webm/libvpx.git' + '@' +  'c22b17dcefe05981918e4b7d0b6527c27e9ceda8',
+    Var('chromium_git') + '/webm/libvpx.git' + '@' +  'cbb83ba4aa99b40b0b4a2a407bfd6d0d8be87d1f',
 
   'src/third_party/ffmpeg':
     Var('chromium_git') + '/chromium/third_party/ffmpeg.git' + '@' + 'dbbdb1680bd8e77ea72f8e5a79a09101bd7a9bdd',

base/BUILD.gn

diff --git a/base/BUILD.gn b/base/BUILD.gn
index dadcf80..1d262c2 100644
--- a/base/BUILD.gn
+++ b/base/BUILD.gn
@@ -1234,6 +1234,7 @@
       "base_paths_fuchsia.cc",
       "debug/stack_trace_fuchsia.cc",
       "files/file_path_watcher_fuchsia.cc",
+      "fuchsia/scoped_mx_handle.h",
       "memory/shared_memory_fuchsia.cc",
       "memory/shared_memory_handle_fuchsia.cc",
       "message_loop/message_pump_fuchsia.cc",

base/fuchsia/scoped_mx_handle.h

diff --git a/base/fuchsia/scoped_mx_handle.h b/base/fuchsia/scoped_mx_handle.h
new file mode 100644
index 0000000..b31601e
--- /dev/null
+++ b/base/fuchsia/scoped_mx_handle.h
@@ -0,0 +1,33 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_FUCHSIA_SCOPED_MX_HANDLE_H_
+#define BASE_FUCHSIA_SCOPED_MX_HANDLE_H_
+
+#include <magenta/status.h>
+#include <magenta/syscalls.h>
+
+#include "base/logging.h"
+#include "base/scoped_generic.h"
+
+namespace base {
+
+namespace internal {
+
+struct ScopedMxHandleTraits {
+  static mx_handle_t InvalidValue() { return MX_HANDLE_INVALID; }
+  static void Free(mx_handle_t object) {
+    mx_status_t status = mx_handle_close(object);
+    CHECK_EQ(MX_OK, status) << mx_status_get_string(status);
+  }
+};
+
+}  // namespace internal
+
+using ScopedMxHandle =
+    ScopedGeneric<mx_handle_t, internal::ScopedMxHandleTraits>;
+
+}  // namespace base
+
+#endif  // BASE_FUCHSIA_SCOPED_MX_HANDLE_H_

base/memory/shared_memory_fuchsia.cc

diff --git a/base/memory/shared_memory_fuchsia.cc b/base/memory/shared_memory_fuchsia.cc
index c622308c..3e8ab001 100644
--- a/base/memory/shared_memory_fuchsia.cc
+++ b/base/memory/shared_memory_fuchsia.cc
@@ -11,6 +11,7 @@
 #include <magenta/syscalls.h>
 
 #include "base/bits.h"
+#include "base/fuchsia/scoped_mx_handle.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory_tracker.h"
 #include "base/process/process_metrics.h"
@@ -49,10 +50,10 @@
 }
 
 bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
-  mx_handle_t vmo;
   requested_size_ = options.size;
   mapped_size_ = bits::Align(requested_size_, GetPageSize());
-  mx_status_t status = mx_vmo_create(mapped_size_, 0, &vmo);
+  ScopedMxHandle vmo;
+  mx_status_t status = mx_vmo_create(mapped_size_, 0, vmo.receive());
   if (status != MX_OK) {
     DLOG(ERROR) << "mx_vmo_create failed, status=" << status;
     return false;
@@ -61,15 +62,18 @@
   if (!options.executable) {
     // If options.executable isn't set, drop that permission by replacement.
     const int kNoExecFlags = MX_DEFAULT_VMO_RIGHTS & ~MX_RIGHT_EXECUTE;
-    status = mx_handle_replace(vmo, kNoExecFlags, &vmo);
+    ScopedMxHandle old_vmo(std::move(vmo));
+    status = mx_handle_replace(old_vmo.get(), kNoExecFlags, vmo.receive());
     if (status != MX_OK) {
-      DLOG(ERROR) << "mx_handle_replace failed, status=" << status;
-      mx_handle_close(vmo);
+      DLOG(ERROR) << "mx_handle_replace() failed: "
+                  << mx_status_get_string(status);
       return false;
     }
+    ignore_result(old_vmo.release());
   }
 
-  shm_ = SharedMemoryHandle(vmo, mapped_size_, UnguessableToken::Create());
+  shm_ = SharedMemoryHandle(vmo.release(), mapped_size_,
+                            UnguessableToken::Create());
   return true;
 }
 

base/memory/shared_memory_unittest.cc

diff --git a/base/memory/shared_memory_unittest.cc b/base/memory/shared_memory_unittest.cc
index c37e5b7..937612a 100644
--- a/base/memory/shared_memory_unittest.cc
+++ b/base/memory/shared_memory_unittest.cc
@@ -40,6 +40,7 @@
 #if defined(OS_FUCHSIA)
 #include <magenta/process.h>
 #include <magenta/syscalls.h>
+#include "base/fuchsia/scoped_mx_handle.h"
 #endif
 
 namespace base {
@@ -377,15 +378,14 @@
                                contents.size(), MX_VM_FLAG_PERM_WRITE, &addr))
       << "Shouldn't be able to map as writable.";
 
-  mx_handle_t duped_handle;
+  ScopedMxHandle duped_handle;
   EXPECT_NE(MX_OK, mx_handle_duplicate(handle.GetHandle(), MX_RIGHT_WRITE,
-                                       &duped_handle))
+                                       duped_handle.receive()))
       << "Shouldn't be able to duplicate the handle into a writable one.";
 
   EXPECT_EQ(MX_OK, mx_handle_duplicate(handle.GetHandle(), MX_RIGHT_READ,
-                                       &duped_handle))
+                                       duped_handle.receive()))
       << "Should be able to duplicate the handle into a readable one.";
-  EXPECT_EQ(MX_OK, mx_handle_close(duped_handle));
 #elif defined(OS_POSIX)
   int handle_fd = SharedMemory::GetFdFromSharedMemoryHandle(handle);
   EXPECT_EQ(O_RDONLY, fcntl(handle_fd, F_GETFL) & O_ACCMODE)

base/message_loop/message_pump_fuchsia.cc

diff --git a/base/message_loop/message_pump_fuchsia.cc b/base/message_loop/message_pump_fuchsia.cc
index 20948bae..5dd8c16 100644
--- a/base/message_loop/message_pump_fuchsia.cc
+++ b/base/message_loop/message_pump_fuchsia.cc
@@ -33,7 +33,7 @@
   if (!weak_pump_ || handle_ == MX_HANDLE_INVALID)
     return true;
 
-  int result = mx_port_cancel(weak_pump_->port_, handle_, wait_key());
+  int result = mx_port_cancel(weak_pump_->port_.get(), handle_, wait_key());
   DLOG_IF(ERROR, result != MX_OK)
       << "mx_port_cancel(handle=" << handle_
       << ") failed: " << mx_status_get_string(result);
@@ -44,14 +44,7 @@
 
 MessagePumpFuchsia::MessagePumpFuchsia()
     : keep_running_(true), weak_factory_(this) {
-  CHECK_EQ(MX_OK, mx_port_create(0, &port_));
-}
-
-MessagePumpFuchsia::~MessagePumpFuchsia() {
-  mx_status_t status = mx_handle_close(port_);
-  if (status != MX_OK) {
-    DLOG(ERROR) << "mx_handle_close failed: " << mx_status_get_string(status);
-  }
+  CHECK_EQ(MX_OK, mx_port_create(0, port_.receive()));
 }
 
 bool MessagePumpFuchsia::WatchFileDescriptor(int fd,
@@ -103,12 +96,13 @@
     return false;
   }
 
-  mx_status_t status = mx_object_wait_async(
-      handle_, weak_pump_->port_, wait_key(), signals, MX_WAIT_ASYNC_ONCE);
+  mx_status_t status =
+      mx_object_wait_async(handle_, weak_pump_->port_.get(), wait_key(),
+                           signals, MX_WAIT_ASYNC_ONCE);
   if (status != MX_OK) {
     DLOG(ERROR) << "mx_object_wait_async failed: "
                 << mx_status_get_string(status)
-                << " (port=" << weak_pump_->port_ << ")";
+                << " (port=" << weak_pump_->port_.get() << ")";
     return false;
   }
   return true;
@@ -157,7 +151,8 @@
                              : delayed_work_time_.ToMXTime();
     mx_port_packet_t packet;
 
-    const mx_status_t wait_status = mx_port_wait(port_, deadline, &packet, 0);
+    const mx_status_t wait_status =
+        mx_port_wait(port_.get(), deadline, &packet, 0);
     if (wait_status != MX_OK && wait_status != MX_ERR_TIMED_OUT) {
       NOTREACHED() << "unexpected wait status: "
                    << mx_status_get_string(wait_status);
@@ -210,9 +205,9 @@
   // wakes up.
   mx_port_packet_t packet = {};
   packet.type = MX_PKT_TYPE_USER;
-  mx_status_t status = mx_port_queue(port_, &packet, 0);
+  mx_status_t status = mx_port_queue(port_.get(), &packet, 0);
   DLOG_IF(ERROR, status != MX_OK)
-      << "mx_port_queue failed: " << status << " (port=" << port_ << ")";
+      << "mx_port_queue failed: " << status << " (port=" << port_.get() << ")";
 }
 
 void MessagePumpFuchsia::ScheduleDelayedWork(

base/message_loop/message_pump_fuchsia.h

diff --git a/base/message_loop/message_pump_fuchsia.h b/base/message_loop/message_pump_fuchsia.h
index 001de34..500310d 100644
--- a/base/message_loop/message_pump_fuchsia.h
+++ b/base/message_loop/message_pump_fuchsia.h
@@ -6,6 +6,7 @@
 #define BASE_MESSAGE_LOOP_MESSAGE_PUMP_FUCHSIA_H_
 
 #include "base/base_export.h"
+#include "base/fuchsia/scoped_mx_handle.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
@@ -98,7 +99,6 @@
   };
 
   MessagePumpFuchsia();
-  ~MessagePumpFuchsia() override;
 
   bool WatchFileDescriptor(int fd,
                            bool persistent,
@@ -116,7 +116,7 @@
   // This flag is set to false when Run should return.
   bool keep_running_;
 
-  mx_handle_t port_;
+  ScopedMxHandle port_;
 
   // The time at which we should call DoDelayedWork.
   TimeTicks delayed_work_time_;

base/process/process.h

diff --git a/base/process/process.h b/base/process/process.h
index 940ab5a0..a4d77dfa 100644
--- a/base/process/process.h
+++ b/base/process/process.h
@@ -15,6 +15,10 @@
 #include "base/win/scoped_handle.h"
 #endif
 
+#if defined(OS_FUCHSIA)
+#include "base/fuchsia/scoped_mx_handle.h"
+#endif
+
 #if defined(OS_MACOSX)
 #include "base/feature_list.h"
 #include "base/process/port_provider_mac.h"
@@ -167,6 +171,8 @@
  private:
 #if defined(OS_WIN)
   win::ScopedHandle process_;
+#elif defined(OS_FUCHSIA)
+  ScopedMxHandle process_;
 #else
   ProcessHandle process_;
 #endif

base/process/process_fuchsia.cc

diff --git a/base/process/process_fuchsia.cc b/base/process/process_fuchsia.cc
index 1c421a75..ec16e28 100644
--- a/base/process/process_fuchsia.cc
+++ b/base/process/process_fuchsia.cc
@@ -21,14 +21,13 @@
 }
 
 Process::Process(Process&& other)
-    : process_(other.process_), is_current_process_(other.is_current_process_) {
-  other.process_ = kNullProcessHandle;
+    : process_(std::move(other.process_)),
+      is_current_process_(other.is_current_process_) {
   other.is_current_process_ = false;
 }
 
 Process& Process::operator=(Process&& other) {
-  process_ = other.process_;
-  other.process_ = kNullProcessHandle;
+  process_ = std::move(other.process_);
   is_current_process_ = other.is_current_process_;
   other.is_current_process_ = false;
   return *this;
@@ -48,14 +47,14 @@
 
   // While a process with object id |pid| might exist, the job returned by
   // mx_job_default() might not contain it, so this call can fail.
-  mx_handle_t handle;
-  mx_status_t status =
-      mx_object_get_child(mx_job_default(), pid, MX_RIGHT_SAME_RIGHTS, &handle);
+  ScopedMxHandle handle;
+  mx_status_t status = mx_object_get_child(
+      mx_job_default(), pid, MX_RIGHT_SAME_RIGHTS, handle.receive());
   if (status != MX_OK) {
     DLOG(ERROR) << "mx_object_get_child failed: " << status;
     return Process();
   }
-  return Process(handle);
+  return Process(handle.release());
 }
 
 // static
@@ -67,13 +66,14 @@
 // static
 Process Process::DeprecatedGetProcessFromHandle(ProcessHandle handle) {
   DCHECK_NE(handle, GetCurrentProcessHandle());
-  mx_handle_t out;
-  if (mx_handle_duplicate(handle, MX_RIGHT_SAME_RIGHTS, &out) != MX_OK) {
+  ScopedMxHandle out;
+  if (mx_handle_duplicate(handle, MX_RIGHT_SAME_RIGHTS, out.receive()) !=
+      MX_OK) {
     DLOG(ERROR) << "mx_handle_duplicate failed: " << handle;
     return Process();
   }
 
-  return Process(out);
+  return Process(out.release());
 }
 
 // static
@@ -87,11 +87,11 @@
 }
 
 bool Process::IsValid() const {
-  return process_ != kNullProcessHandle || is_current();
+  return process_.is_valid() || is_current();
 }
 
 ProcessHandle Process::Handle() const {
-  return is_current_process_ ? mx_process_self() : process_;
+  return is_current_process_ ? mx_process_self() : process_.get();
 }
 
 Process Process::Duplicate() const {
@@ -101,18 +101,19 @@
   if (!IsValid())
     return Process();
 
-  mx_handle_t out;
-  if (mx_handle_duplicate(process_, MX_RIGHT_SAME_RIGHTS, &out) != MX_OK) {
-    DLOG(ERROR) << "mx_handle_duplicate failed: " << process_;
+  ScopedMxHandle out;
+  if (mx_handle_duplicate(process_.get(), MX_RIGHT_SAME_RIGHTS,
+                          out.receive()) != MX_OK) {
+    DLOG(ERROR) << "mx_handle_duplicate failed: " << process_.get();
     return Process();
   }
 
-  return Process(out);
+  return Process(out.release());
 }
 
 ProcessId Process::Pid() const {
   DCHECK(IsValid());
-  return GetProcId(process_);
+  return GetProcId(process_.get());
 }
 
 bool Process::is_current() const {
@@ -121,21 +122,17 @@
 
 void Process::Close() {
   is_current_process_ = false;
-  if (IsValid()) {
-    mx_status_t status = mx_handle_close(process_);
-    DCHECK_EQ(status, MX_OK);
-    process_ = kNullProcessHandle;
-  }
+  process_.reset();
 }
 
 bool Process::Terminate(int exit_code, bool wait) const {
   // exit_code isn't supportable.
-  mx_status_t status = mx_task_kill(process_);
+  mx_status_t status = mx_task_kill(process_.get());
   // TODO(scottmg): Put these LOG/CHECK back to DLOG/DCHECK after
   // https://crbug.com/750756 is diagnosed.
   if (status == MX_OK && wait) {
     mx_signals_t signals;
-    status = mx_object_wait_one(process_, MX_TASK_TERMINATED,
+    status = mx_object_wait_one(process_.get(), MX_TASK_TERMINATED,
                                 mx_deadline_after(MX_SEC(60)), &signals);
     if (status != MX_OK) {
       LOG(ERROR) << "Error waiting for process exit: " << status;
@@ -161,7 +158,7 @@
                            ? MX_TIME_INFINITE
                            : (TimeTicks::Now() + timeout).ToMXTime();
   mx_signals_t signals_observed = 0;
-  mx_status_t status = mx_object_wait_one(process_, MX_TASK_TERMINATED,
+  mx_status_t status = mx_object_wait_one(process_.get(), MX_TASK_TERMINATED,
                                           deadline, &signals_observed);
 
   // TODO(scottmg): Make these LOGs into DLOGs after https://crbug.com/750756 is
@@ -177,7 +174,7 @@
   }
 
   mx_info_process_t proc_info;
-  status = mx_object_get_info(process_, MX_INFO_PROCESS, &proc_info,
+  status = mx_object_get_info(process_.get(), MX_INFO_PROCESS, &proc_info,
                               sizeof(proc_info), nullptr, nullptr);
   if (status != MX_OK) {
     LOG(ERROR) << "mx_object_get_info failed, status=" << status;

base/scoped_generic.h

diff --git a/base/scoped_generic.h b/base/scoped_generic.h
index c2d51cfd..25e6208 100644
--- a/base/scoped_generic.h
+++ b/base/scoped_generic.h
@@ -124,6 +124,13 @@
     return old_generic;
   }
 
+  // Returns a raw pointer to the object storage, to allow the scoper to be used
+  // to receive and manage out-parameter values. Implies reset().
+  element_type* receive() WARN_UNUSED_RESULT {
+    reset();
+    return &data_.generic;
+  }
+
   const element_type& get() const { return data_.generic; }
 
   // Returns true if this object doesn't hold the special null value for the

base/test/scoped_task_environment.cc

diff --git a/base/test/scoped_task_environment.cc b/base/test/scoped_task_environment.cc
index 998d0aa8..e3f9f2f 100644
--- a/base/test/scoped_task_environment.cc
+++ b/base/test/scoped_task_environment.cc
@@ -46,7 +46,9 @@
   TestTaskTracker();
 
   void RegisterOnQueueEmptyClosure(OnceClosure queue_empty_closure);
-  void AssertOnQueueEmptyClosureIsNull();
+
+  // Returns true if closure needed reset.
+  bool ResetOnQueueEmptyClosureIfNotNull();
 
   // Allow running tasks.
   void AllowRunRask();
@@ -154,7 +156,12 @@
     run_loop.Run();
     MessageLoop::current()->RemoveTaskObserver(&task_observer);
 
-    task_tracker_->AssertOnQueueEmptyClosureIsNull();
+    // If |task_tracker_|'s |queue_empty_closure_| is not null, it means that
+    // external code exited the RunLoop (through deprecated static methods) and
+    // that the MessageLoop and TaskScheduler queues might not be empty. Run the
+    // loop again to make sure that no task remains.
+    if (task_tracker_->ResetOnQueueEmptyClosureIfNotNull())
+      continue;
 
     // If tasks other than the QuitWhenIdle closure ran on the main thread, they
     // may have posted TaskScheduler tasks that didn't run yet. Another
@@ -187,9 +194,15 @@
   queue_empty_closure_ = std::move(queue_empty_closure);
 }
 
-void ScopedTaskEnvironment::TestTaskTracker::AssertOnQueueEmptyClosureIsNull() {
+bool ScopedTaskEnvironment::TestTaskTracker::
+    ResetOnQueueEmptyClosureIfNotNull() {
   AutoLock auto_lock(lock_);
-  CHECK(!queue_empty_closure_);
+  if (queue_empty_closure_) {
+    queue_empty_closure_ = Closure();
+    return true;
+  }
+
+  return false;
 }
 
 void ScopedTaskEnvironment::TestTaskTracker::AllowRunRask() {

build/config/c++/c++.gni

diff --git a/build/config/c++/c++.gni b/build/config/c++/c++.gni
index 5052b369a..13e2cfa 100644
--- a/build/config/c++/c++.gni
+++ b/build/config/c++/c++.gni
@@ -12,7 +12,7 @@
   # is not supported.
   use_custom_libcxx =
       is_msan || is_fuchsia ||
-      (is_linux &&
+      (is_linux && is_clang &&
        (!is_chromeos || default_toolchain != "//build/toolchain/cros:target"))
 
   # ASan, MSan and TSan builds need to override operator new, operator delete,

build/config/fuchsia/BUILD.gn

diff --git a/build/config/fuchsia/BUILD.gn b/build/config/fuchsia/BUILD.gn
index fbc3185..ee1946ba 100644
--- a/build/config/fuchsia/BUILD.gn
+++ b/build/config/fuchsia/BUILD.gn
@@ -28,6 +28,18 @@
   }
   asmflags = cflags
 
+  # TODO(thakis): Once Fuchsia's libclang_rt.builtin no longer has upstream
+  # patches, we might want to make tools/clang/scripts/update.py build it
+  # and bundle it with the clang package instead of using the library from
+  # the SDK, https://crbug.com/724204
+  # Note: Intentionally 6.0.0 instead of $clang_version because the clang
+  # version of the toolchain_libs directory in the Fuchsia SDK can be
+  # different from the version of Chromium's clang.
+  ldflags += [
+    "-resource-dir",
+    rebase_path(fuchsia_sdk, root_build_dir) + "/toolchain_libs/clang/6.0.0",
+  ]
+
   ldflags += [
     # The stack defaults to 256k on Fuchsia (see
     # https://fuchsia.googlesource.com/magenta/+/master/system/private/magenta/stack.h#9),

build/config/posix/BUILD.gn

diff --git a/build/config/posix/BUILD.gn b/build/config/posix/BUILD.gn
index b8ab461..6609290 100644
--- a/build/config/posix/BUILD.gn
+++ b/build/config/posix/BUILD.gn
@@ -58,45 +58,7 @@
     }
 
     # Make sure we don't link against libc++ or libstdc++.
-    ldflags += [ "-nodefaultlibs" ]
-
-    # Unfortunately, there's no way to disable linking against just
-    # libc++ (besides using clang instead of clang++); -nodefaultlibs
-    # removes all of the default libraries, so add back the ones that we
-    # need.
-    libs += [
-      "c",
-      "m",
-    ]
-
-    if (!is_mac && !is_fuchsia) {
-      libs += [
-        "gcc_s",
-        "rt",
-      ]
-    } else if (is_fuchsia) {
-      # TODO(thakis): Once Fuchsia's libclang_rt.builtin no longer has upstream
-      # patches, we might want to make tools/clang/scripts/update.py build it
-      # and bundle it with the clang package instead of using the library from
-      # the SDK, https://crbug.com/724204
-      # If clang grows a flag like -nodefaultlibs++, then this here should use
-      # -resource-dir instead.
-      # Note: Intentionally 6.0.0 instead of $clang_version because the clang
-      # version of the toolchain_libs directory in the Fuchsia SDK can be
-      # different from the version of Chromium's clang.
-      lib_dirs += [ "$fuchsia_sdk/toolchain_libs/clang/6.0.0/lib/fuchsia" ]
-
-      # TODO(fuchsia): We probably want to support more archs one day.
-      libs += [ "clang_rt.builtins-x86_64" ]
-    }
-
-    if (is_mac && using_sanitizer) {
-      lib_dirs += [ "//third_party/llvm-build/Release+Asserts/lib/clang/$clang_version/lib/darwin" ]
-
-      if (is_asan) {
-        libs += [ "clang_rt.asan_osx_dynamic" ]
-      }
-    }
+    ldflags += [ "-nostdlib++" ]
   }
 
   if (!is_mac && !is_ios && sysroot != "") {

cc/ipc/BUILD.gn

diff --git a/cc/ipc/BUILD.gn b/cc/ipc/BUILD.gn
index 477bd02..3a267f92 100644
--- a/cc/ipc/BUILD.gn
+++ b/cc/ipc/BUILD.gn
@@ -53,7 +53,6 @@
     "shared_bitmap_allocation_notifier.mojom",
     "shared_quad_state.mojom",
     "surface_id.mojom",
-    "surface_info.mojom",
     "surface_sequence.mojom",
     "texture_mailbox.mojom",
     "texture_mailbox_releaser.mojom",

cc/ipc/cc_param_traits.cc

diff --git a/cc/ipc/cc_param_traits.cc b/cc/ipc/cc_param_traits.cc
index ac511a2..16e47ac 100644
--- a/cc/ipc/cc_param_traits.cc
+++ b/cc/ipc/cc_param_traits.cc
@@ -9,6 +9,7 @@
 
 #include "base/numerics/safe_conversions.h"
 #include "base/time/time.h"
+#include "base/trace_event/trace_event.h"
 #include "base/unguessable_token.h"
 #include "cc/base/filter_operations.h"
 #include "cc/output/compositor_frame.h"
@@ -74,6 +75,8 @@
 
 void ParamTraits<cc::FilterOperation>::Write(base::Pickle* m,
                                              const param_type& p) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "ParamTraits::FilterOperation::Write");
   WriteParam(m, p.type());
   switch (p.type()) {
     case cc::FilterOperation::GRAYSCALE:
@@ -116,6 +119,8 @@
 bool ParamTraits<cc::FilterOperation>::Read(const base::Pickle* m,
                                             base::PickleIterator* iter,
                                             param_type* r) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "ParamTraits::FilterOperation::Read");
   cc::FilterOperation::FilterType type;
   float amount;
   gfx::Point drop_shadow_offset;
@@ -259,6 +264,8 @@
 
 void ParamTraits<cc::FilterOperations>::Write(base::Pickle* m,
                                               const param_type& p) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "ParamTraits::FilterOperations::Write");
   WriteParam(m, base::checked_cast<uint32_t>(p.size()));
   for (std::size_t i = 0; i < p.size(); ++i) {
     WriteParam(m, p.at(i));
@@ -268,6 +275,8 @@
 bool ParamTraits<cc::FilterOperations>::Read(const base::Pickle* m,
                                              base::PickleIterator* iter,
                                              param_type* r) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "ParamTraits::FilterOperations::Read");
   uint32_t count;
   if (!ReadParam(m, iter, &count))
     return false;
@@ -305,6 +314,8 @@
 
 void ParamTraits<sk_sp<SkImageFilter>>::Write(base::Pickle* m,
                                               const param_type& p) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "ParamTraits::SkImageFilter::Write");
   SkImageFilter* filter = p.get();
   if (filter) {
     sk_sp<SkData> data(SkValidatingSerializeFlattenable(filter));
@@ -318,6 +329,8 @@
 bool ParamTraits<sk_sp<SkImageFilter>>::Read(const base::Pickle* m,
                                              base::PickleIterator* iter,
                                              param_type* r) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "ParamTraits::SkImageFilter::Read");
   const char* data = 0;
   int length = 0;
   if (!iter->ReadData(&data, &length))
@@ -340,6 +353,8 @@
 }
 
 void ParamTraits<cc::RenderPass>::Write(base::Pickle* m, const param_type& p) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "ParamTraits::RenderPass::Write");
   WriteParam(m, p.id);
   WriteParam(m, p.output_rect);
   WriteParam(m, p.damage_rect);
@@ -444,6 +459,8 @@
 static cc::DrawQuad* ReadDrawQuad(const base::Pickle* m,
                                   base::PickleIterator* iter,
                                   cc::RenderPass* render_pass) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "ParamTraits::ReadDrawQuad");
   QuadType* quad = render_pass->CreateAndAppendDrawQuad<QuadType>();
   if (!ReadParam(m, iter, quad))
     return nullptr;
@@ -453,6 +470,8 @@
 bool ParamTraits<cc::RenderPass>::Read(const base::Pickle* m,
                                        base::PickleIterator* iter,
                                        param_type* p) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "ParamTraits::RenderPass::Read");
   uint64_t id;
   gfx::Rect output_rect;
   gfx::Rect damage_rect;
@@ -795,6 +814,8 @@
 
 void ParamTraits<cc::CompositorFrame>::Write(base::Pickle* m,
                                              const param_type& p) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "ParamTraits::CompositorFrame::Write");
   WriteParam(m, p.metadata);
   size_t to_reserve = 0u;
   to_reserve += p.resource_list.size() * sizeof(viz::TransferableResource);
@@ -817,6 +838,8 @@
 bool ParamTraits<cc::CompositorFrame>::Read(const base::Pickle* m,
                                             base::PickleIterator* iter,
                                             param_type* p) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "ParamTraits::CompositorFrame::Read");
   if (!ReadParam(m, iter, &p->metadata))
     return false;
 
@@ -885,6 +908,8 @@
 
 void ParamTraits<cc::DrawQuad::Resources>::Write(base::Pickle* m,
                                                  const param_type& p) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "ParamTraits::DrawQuad::Resources::Write");
   DCHECK_LE(p.count, cc::DrawQuad::Resources::kMaxResourceIdCount);
   WriteParam(m, p.count);
   for (size_t i = 0; i < p.count; ++i)
@@ -894,6 +919,8 @@
 bool ParamTraits<cc::DrawQuad::Resources>::Read(const base::Pickle* m,
                                                 base::PickleIterator* iter,
                                                 param_type* p) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "ParamTraits::DrawQuad::Resources::Read");
   if (!ReadParam(m, iter, &p->count))
     return false;
   if (p->count > cc::DrawQuad::Resources::kMaxResourceIdCount)

cc/ipc/compositor_frame_metadata_struct_traits.cc

diff --git a/cc/ipc/compositor_frame_metadata_struct_traits.cc b/cc/ipc/compositor_frame_metadata_struct_traits.cc
index fc3d85b..9664ef5 100644
--- a/cc/ipc/compositor_frame_metadata_struct_traits.cc
+++ b/cc/ipc/compositor_frame_metadata_struct_traits.cc
@@ -3,6 +3,8 @@
 // found in the LICENSE file.
 
 #include "cc/ipc/compositor_frame_metadata_struct_traits.h"
+
+#include "base/trace_event/trace_event.h"
 #include "cc/ipc/begin_frame_args_struct_traits.h"
 #include "cc/ipc/selection_struct_traits.h"
 #include "cc/ipc/surface_id_struct_traits.h"
@@ -16,6 +18,8 @@
                   cc::CompositorFrameMetadata>::
     Read(cc::mojom::CompositorFrameMetadataDataView data,
          cc::CompositorFrameMetadata* out) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "StructTraits::CompositorFrameMetadata::Read");
   out->device_scale_factor = data.device_scale_factor();
   if (!data.ReadRootScrollOffset(&out->root_scroll_offset))
     return false;

cc/ipc/render_pass_struct_traits.cc

diff --git a/cc/ipc/render_pass_struct_traits.cc b/cc/ipc/render_pass_struct_traits.cc
index 779afce5..7cb7c826 100644
--- a/cc/ipc/render_pass_struct_traits.cc
+++ b/cc/ipc/render_pass_struct_traits.cc
@@ -5,6 +5,7 @@
 #include "cc/ipc/render_pass_struct_traits.h"
 
 #include "base/numerics/safe_conversions.h"
+#include "base/trace_event/trace_event.h"
 #include "cc/ipc/shared_quad_state_struct_traits.h"
 
 namespace mojo {
@@ -14,6 +15,8 @@
                   std::unique_ptr<cc::RenderPass>>::
     Read(cc::mojom::RenderPassDataView data,
          std::unique_ptr<cc::RenderPass>* out) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "StructTraits::RenderPass::Read");
   *out = cc::RenderPass::Create();
   if (!data.ReadOutputRect(&(*out)->output_rect) ||
       !data.ReadDamageRect(&(*out)->damage_rect) ||

cc/ipc/surface_info.typemap

diff --git a/cc/ipc/surface_info.typemap b/cc/ipc/surface_info.typemap
deleted file mode 100644
index 87fd3b8..0000000
--- a/cc/ipc/surface_info.typemap
+++ /dev/null
@@ -1,11 +0,0 @@
-# Copyright 2017 The Chromium Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-mojom = "//cc/ipc/surface_info.mojom"
-public_headers = [ "//components/viz/common/surfaces/surface_info.h" ]
-traits_headers = [ "//cc/ipc/surface_info_struct_traits.h" ]
-deps = [
-  "//components/viz/common",
-]
-type_mappings = [ "cc.mojom.SurfaceInfo=viz::SurfaceInfo" ]

cc/ipc/transferable_resource_struct_traits.cc

diff --git a/cc/ipc/transferable_resource_struct_traits.cc b/cc/ipc/transferable_resource_struct_traits.cc
index 38db3d8..b9baf49 100644
--- a/cc/ipc/transferable_resource_struct_traits.cc
+++ b/cc/ipc/transferable_resource_struct_traits.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "cc/ipc/transferable_resource_struct_traits.h"
+#include "base/trace_event/trace_event.h"
 #include "gpu/ipc/common/mailbox_holder_struct_traits.h"
 #include "gpu/ipc/common/mailbox_struct_traits.h"
 #include "gpu/ipc/common/sync_token_struct_traits.h"
@@ -15,6 +16,8 @@
                   viz::TransferableResource>::
     Read(cc::mojom::TransferableResourceDataView data,
          viz::TransferableResource* out) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "StructTraits::TransferableResource::Read");
   if (!data.ReadSize(&out->size) ||
       !data.ReadMailboxHolder(&out->mailbox_holder) ||
       !data.ReadColorSpace(&out->color_space))

cc/ipc/typemaps.gni

diff --git a/cc/ipc/typemaps.gni b/cc/ipc/typemaps.gni
index 017deb2..f6963c4e 100644
--- a/cc/ipc/typemaps.gni
+++ b/cc/ipc/typemaps.gni
@@ -15,7 +15,6 @@
   "//cc/ipc/selection.typemap",
   "//cc/ipc/shared_quad_state.typemap",
   "//cc/ipc/surface_id.typemap",
-  "//cc/ipc/surface_info.typemap",
   "//cc/ipc/surface_sequence.typemap",
   "//cc/ipc/texture_mailbox.typemap",
   "//cc/ipc/transferable_resource.typemap",

cc/resources/resource_pool.cc

diff --git a/cc/resources/resource_pool.cc b/cc/resources/resource_pool.cc
index d234f848..2e9e0b9 100644
--- a/cc/resources/resource_pool.cc
+++ b/cc/resources/resource_pool.cc
@@ -124,6 +124,12 @@
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       this, "cc::ResourcePool", task_runner_.get());
 
+#if defined(OS_ANDROID)
+  // TODO(ericrk): This feature appears to be causing visual corruption on
+  // certain android devices. Will investigate and re-enable. crbug.com/746931
+  disallow_non_exact_reuse_ = true;
+#endif
+
   // Register this component with base::MemoryCoordinatorClientRegistry.
   base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
 }

cc/resources/resource_pool.h

diff --git a/cc/resources/resource_pool.h b/cc/resources/resource_pool.h
index a9ead051..3eb517b 100644
--- a/cc/resources/resource_pool.h
+++ b/cc/resources/resource_pool.h
@@ -101,6 +101,9 @@
   size_t GetBusyResourceCountForTesting() const {
     return busy_resources_.size();
   }
+  bool AllowsNonExactReUseForTesting() const {
+    return !disallow_non_exact_reuse_;
+  }
 
  protected:
   // Constructor for creating GPU memory buffer resources.

cc/resources/resource_pool_unittest.cc

diff --git a/cc/resources/resource_pool_unittest.cc b/cc/resources/resource_pool_unittest.cc
index d445f07..14ddf372 100644
--- a/cc/resources/resource_pool_unittest.cc
+++ b/cc/resources/resource_pool_unittest.cc
@@ -346,13 +346,23 @@
                                                    color_space));
 
   // Try some cases that are smaller than 100x100, but within 2x area. Reuse
-  // should succeed.
-  CheckAndReturnResource(
-      resource_pool_->ReuseResource(gfx::Size(50, 100), format, color_space));
-  CheckAndReturnResource(
-      resource_pool_->ReuseResource(gfx::Size(100, 50), format, color_space));
-  CheckAndReturnResource(
-      resource_pool_->ReuseResource(gfx::Size(71, 71), format, color_space));
+  // should succeed if non-exact requests are supported. Some platforms never
+  // support these.
+  if (resource_pool_->AllowsNonExactReUseForTesting()) {
+    CheckAndReturnResource(
+        resource_pool_->ReuseResource(gfx::Size(50, 100), format, color_space));
+    CheckAndReturnResource(
+        resource_pool_->ReuseResource(gfx::Size(100, 50), format, color_space));
+    CheckAndReturnResource(
+        resource_pool_->ReuseResource(gfx::Size(71, 71), format, color_space));
+  } else {
+    EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(50, 100), format,
+                                                     color_space));
+    EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(100, 50), format,
+                                                     color_space));
+    EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(71, 71), format,
+                                                     color_space));
+  }
 
   // 100x100 is an exact match and should succeed. A subsequent request for
   // the same size should fail (the resource is already in use).
@@ -434,7 +444,7 @@
       resource_pool_->CreateResource(gfx::Size(100, 100), format, color_space));
 
   // Try some cases that are smaller than 100x100, but within 2x area which
-  // would typically allow reuse. Reuse should fail due to the .
+  // would typically allow reuse. Reuse should fail.
   EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(50, 100), format,
                                                    color_space));
   EXPECT_EQ(nullptr, resource_pool_->ReuseResource(gfx::Size(100, 50), format,

chrome/android/java/src/org/chromium/chrome/browser/ShortcutHelper.java

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/ShortcutHelper.java b/chrome/android/java/src/org/chromium/chrome/browser/ShortcutHelper.java
index e362f9f..8e97f81 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/ShortcutHelper.java
+++ b/chrome/android/java/src/org/chromium/chrome/browser/ShortcutHelper.java
@@ -180,7 +180,6 @@
                         backgroundColor, iconUrl.isEmpty());
                 shortcutIntent.putExtra(EXTRA_MAC, getEncodedMac(context, url));
                 shortcutIntent.putExtra(EXTRA_SOURCE, source);
-                shortcutIntent.setPackage(context.getPackageName());
                 return shortcutIntent;
             }
             @Override
@@ -363,7 +362,8 @@
             boolean isIconGenerated) {
         // Create an intent as a launcher icon for a full-screen Activity.
         Intent shortcutIntent = new Intent();
-        shortcutIntent.setAction(action)
+        shortcutIntent.setPackage(ContextUtils.getApplicationContext().getPackageName())
+                .setAction(action)
                 .putExtra(EXTRA_ID, id)
                 .putExtra(EXTRA_URL, url)
                 .putExtra(EXTRA_SCOPE, scope)

chrome/android/java/src/org/chromium/chrome/browser/download/DownloadBroadcastManager.java

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/download/DownloadBroadcastManager.java b/chrome/android/java/src/org/chromium/chrome/browser/download/DownloadBroadcastManager.java
new file mode 100644
index 0000000..9dd140b
--- /dev/null
+++ b/chrome/android/java/src/org/chromium/chrome/browser/download/DownloadBroadcastManager.java
@@ -0,0 +1,174 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.chrome.browser.download;
+
+import static org.chromium.chrome.browser.download.DownloadNotificationService.ACTION_DOWNLOAD_CANCEL;
+import static org.chromium.chrome.browser.download.DownloadNotificationService.ACTION_DOWNLOAD_OPEN;
+import static org.chromium.chrome.browser.download.DownloadNotificationService.ACTION_DOWNLOAD_PAUSE;
+import static org.chromium.chrome.browser.download.DownloadNotificationService.ACTION_DOWNLOAD_RESUME;
+import static org.chromium.chrome.browser.download.DownloadNotificationService.ACTION_DOWNLOAD_RESUME_ALL;
+import static org.chromium.chrome.browser.download.DownloadNotificationService.EXTRA_IS_OFF_THE_RECORD;
+import static org.chromium.chrome.browser.download.DownloadNotificationService.getContentIdFromIntent;
+import static org.chromium.chrome.browser.download.DownloadNotificationService.getServiceDelegate;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Handler;
+
+import com.google.ipc.invalidation.util.Preconditions;
+
+import org.chromium.base.Log;
+import org.chromium.base.VisibleForTesting;
+import org.chromium.base.library_loader.ProcessInitException;
+import org.chromium.chrome.browser.ChromeApplication;
+import org.chromium.chrome.browser.download.items.OfflineContentAggregatorNotificationBridgeUiFactory;
+import org.chromium.chrome.browser.init.BrowserParts;
+import org.chromium.chrome.browser.init.ChromeBrowserInitializer;
+import org.chromium.chrome.browser.init.EmptyBrowserParts;
+import org.chromium.chrome.browser.offlinepages.downloads.OfflinePageDownloadBridge;
+import org.chromium.chrome.browser.util.IntentUtils;
+import org.chromium.components.offline_items_collection.ContentId;
+import org.chromium.components.offline_items_collection.LegacyHelpers;
+
+/**
+ * Class that spins up native when an interaction with a notification happens and passes the
+ * relevant information on to native.
+ */
+public class DownloadBroadcastManager {
+    private static final String TAG = "DLBroadcastManager";
+    // TODO(jming): Check to see if this wait time is long enough to execute commands on native.
+    private static final int WAIT_TIME_MS = 5000;
+
+    private final DownloadSharedPreferenceHelper mDownloadSharedPreferenceHelper =
+            DownloadSharedPreferenceHelper.getInstance();
+
+    private final Handler mHandler = new Handler();
+    private final Runnable mStopSelfRunnable = new Runnable() {
+        @Override
+        public void run() {
+            // TODO(jming): Add stopSelf() call when this becomes a service.
+        }
+    };
+
+    public DownloadBroadcastManager() {}
+
+    /**
+     * Passes down information about a notification interaction to native.
+     * TODO(jming): Move this call to onStartCommand when this class becomes a service.
+     * @param context of the interaction.
+     * @param intent with information about the notification interaction (action, contentId, etc).
+     */
+    public void onNotificationInteraction(Context context, final Intent intent) {
+        String action = intent.getAction();
+        if (!isActionHandled(action)) return;
+
+        // Remove delayed stop of service until after native library is loaded.
+        mHandler.removeCallbacks(mStopSelfRunnable);
+
+        // Handle the intent and propagate it through the native library.
+        loadNativeAndPropagateInteraction(context, intent);
+    }
+
+    /**
+     * Helper function that loads the native and runs given runnable.
+     * @param context of the application.
+     * @param intent that is propagated when the native is loaded.
+     */
+    @VisibleForTesting
+    void loadNativeAndPropagateInteraction(Context context, final Intent intent) {
+        final BrowserParts parts = new EmptyBrowserParts() {
+            @Override
+            public void finishNativeInitialization() {
+                // Delay the stop of the service by WAIT_TIME_MS after native library is loaded.
+                mHandler.postDelayed(mStopSelfRunnable, WAIT_TIME_MS);
+
+                // Make sure the OfflineContentAggregator bridge is initialized.
+                OfflineContentAggregatorNotificationBridgeUiFactory.instance();
+                propagateInteraction(intent);
+            }
+        };
+
+        try {
+            ChromeBrowserInitializer.getInstance(context).handlePreNativeStartup(parts);
+            ChromeBrowserInitializer.getInstance(context).handlePostNativeStartup(true, parts);
+        } catch (ProcessInitException e) {
+            Log.e(TAG, "Unable to load native library.", e);
+            ChromeApplication.reportStartupErrorAndExit(e);
+        }
+    }
+
+    @VisibleForTesting
+    void propagateInteraction(Intent intent) {
+        String action = intent.getAction();
+        final ContentId id = getContentIdFromIntent(intent);
+        final DownloadSharedPreferenceEntry entry = getDownloadEntryFromIntent(intent);
+        boolean isOffTheRecord = entry == null
+                ? IntentUtils.safeGetBooleanExtra(intent, EXTRA_IS_OFF_THE_RECORD, false)
+                : entry.isOffTheRecord;
+
+        DownloadServiceDelegate downloadServiceDelegate =
+                ACTION_DOWNLOAD_OPEN.equals(action) ? null : getServiceDelegate(id);
+
+        switch (action) {
+            case ACTION_DOWNLOAD_CANCEL:
+                Preconditions.checkNotNull(downloadServiceDelegate);
+                Preconditions.checkNotNull(id);
+
+                downloadServiceDelegate.cancelDownload(id, isOffTheRecord);
+                break;
+
+            case ACTION_DOWNLOAD_PAUSE:
+                Preconditions.checkNotNull(downloadServiceDelegate);
+                Preconditions.checkNotNull(id);
+
+                downloadServiceDelegate.pauseDownload(id, isOffTheRecord);
+                break;
+
+            case ACTION_DOWNLOAD_RESUME:
+                Preconditions.checkNotNull(downloadServiceDelegate);
+                Preconditions.checkNotNull(id);
+
+                DownloadInfo info = new DownloadInfo.Builder()
+                                            .setDownloadGuid(id.id)
+                                            .setIsOffTheRecord(isOffTheRecord)
+                                            .build();
+
+                downloadServiceDelegate.resumeDownload(
+                        id, new DownloadItem(false, info), true /* hasUserGesture */);
+                break;
+
+            case ACTION_DOWNLOAD_OPEN:
+                if (LegacyHelpers.isLegacyOfflinePage(id)) {
+                    OfflinePageDownloadBridge.openDownloadedPage(id);
+                } else if (id != null) {
+                    OfflineContentAggregatorNotificationBridgeUiFactory.instance().openItem(id);
+                }
+                break;
+
+            default:
+                // No-op.
+                break;
+        }
+
+        if (downloadServiceDelegate != null) downloadServiceDelegate.destroyServiceDelegate();
+    }
+
+    private boolean isActionHandled(String action) {
+        return ACTION_DOWNLOAD_CANCEL.equals(action) || ACTION_DOWNLOAD_PAUSE.equals(action)
+                || ACTION_DOWNLOAD_RESUME.equals(action) || ACTION_DOWNLOAD_OPEN.equals(action);
+    }
+
+    /**
+     * Retrieves DownloadSharedPreferenceEntry from a download action intent.
+     * TODO(jming): Make private when no longer needed by DownloadNotificationService.
+     * TODO(jming): Instead of getting entire entry, pass only id/isOffTheRecord (crbug.com/749323).
+     * @param intent Intent that contains the download action.
+     */
+    DownloadSharedPreferenceEntry getDownloadEntryFromIntent(Intent intent) {
+        if (ACTION_DOWNLOAD_RESUME_ALL.equals(intent.getAction())) return null;
+        return mDownloadSharedPreferenceHelper.getDownloadSharedPreferenceEntry(
+                getContentIdFromIntent(intent));
+    }
+}

chrome/android/java/src/org/chromium/chrome/browser/download/DownloadNotificationService.java

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/download/DownloadNotificationService.java b/chrome/android/java/src/org/chromium/chrome/browser/download/DownloadNotificationService.java
index 38a59e5..d7c25ae 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/download/DownloadNotificationService.java
+++ b/chrome/android/java/src/org/chromium/chrome/browser/download/DownloadNotificationService.java
@@ -35,15 +35,10 @@
 import org.chromium.base.ObserverList;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.library_loader.LibraryProcessType;
-import org.chromium.base.library_loader.ProcessInitException;
 import org.chromium.base.metrics.RecordHistogram;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.AppHooks;
-import org.chromium.chrome.browser.ChromeApplication;
 import org.chromium.chrome.browser.download.items.OfflineContentAggregatorNotificationBridgeUiFactory;
-import org.chromium.chrome.browser.init.BrowserParts;
-import org.chromium.chrome.browser.init.ChromeBrowserInitializer;
-import org.chromium.chrome.browser.init.EmptyBrowserParts;
 import org.chromium.chrome.browser.notifications.NotificationConstants;
 import org.chromium.chrome.browser.notifications.NotificationUmaTracker;
 import org.chromium.chrome.browser.notifications.channels.ChannelDefinitions;
@@ -137,6 +132,7 @@
     private int mNumAutoResumptionAttemptLeft;
     private Bitmap mDownloadSuccessLargeIcon;
     private DownloadSharedPreferenceHelper mDownloadSharedPreferenceHelper;
+    private DownloadBroadcastManager mDownloadBroadcastManager;
 
     /**
      * @return Whether or not this service should be made a foreground service if there are active
@@ -404,6 +400,7 @@
         mDownloadSharedPreferenceHelper = DownloadSharedPreferenceHelper.getInstance();
         mNextNotificationId = mSharedPrefs.getInt(
                 KEY_NEXT_DOWNLOAD_NOTIFICATION_ID, STARTING_NOTIFICATION_ID);
+        mDownloadBroadcastManager = new DownloadBroadcastManager();
     }
 
     @Override
@@ -499,12 +496,6 @@
         return hasDownloadNotifications(mNotificationManager, notificationIdToIgnore);
     }
 
-    @VisibleForTesting
-    void updateSummaryIconInternal(
-            int removedNotificationId, Pair<Integer, Notification> addedNotification) {
-        updateSummaryIcon(mContext, mNotificationManager, removedNotificationId, addedNotification);
-    }
-
     private void rescheduleDownloads() {
         // Cancel any existing task.  If we have any downloads to resume we'll reschedule another
         // one.
@@ -970,14 +961,9 @@
         return result;
     }
 
-    /**
-     * Retrieves DownloadSharedPreferenceEntry from a download action intent.
-     * @param intent Intent that contains the download action.
-     */
-    private DownloadSharedPreferenceEntry getDownloadEntryFromIntent(Intent intent) {
-        if (ACTION_DOWNLOAD_RESUME_ALL.equals(intent.getAction())) return null;
-        return mDownloadSharedPreferenceHelper.getDownloadSharedPreferenceEntry(
-                getContentIdFromIntent(intent));
+    @VisibleForTesting
+    void setDownloadBroadcastManager(DownloadBroadcastManager downloadBroadcastManager) {
+        mDownloadBroadcastManager = downloadBroadcastManager;
     }
 
     /**
@@ -986,9 +972,11 @@
      * @param intent Intent with the download operation.
      */
     private void handleDownloadOperation(final Intent intent) {
+        String action = intent.getAction();
+
         // Process updating the summary notification first.  This has no impact on a specific
         // download.
-        if (ACTION_DOWNLOAD_UPDATE_SUMMARY_ICON.equals(intent.getAction())) {
+        if (ACTION_DOWNLOAD_UPDATE_SUMMARY_ICON.equals(action)) {
             updateSummaryIcon(mContext, mNotificationManager, -1, null);
             hideSummaryNotificationIfNecessary(-1);
             return;
@@ -996,143 +984,94 @@
 
         // TODO(qinmin): Figure out how to properly handle this case.
         final ContentId id = getContentIdFromIntent(intent);
-        final DownloadSharedPreferenceEntry entry = getDownloadEntryFromIntent(intent);
+        final DownloadSharedPreferenceEntry entry =
+                mDownloadBroadcastManager.getDownloadEntryFromIntent(intent);
         if (entry == null
                 && !(id != null && LegacyHelpers.isLegacyOfflinePage(id)
                            && TextUtils.equals(intent.getAction(), ACTION_DOWNLOAD_OPEN))) {
-            handleDownloadOperationForMissingNotification(intent);
+            mDownloadBroadcastManager.onNotificationInteraction(mContext, intent);
             hideSummaryNotificationIfNecessary(-1);
             return;
         }
 
-        if (ACTION_DOWNLOAD_PAUSE.equals(intent.getAction())) {
-            // If browser process already goes away, the download should have already paused. Do
-            // nothing in that case.
-            if (!DownloadManagerService.hasDownloadManagerService()) {
-                // TODO(dtrainor): Should we spin up native to make sure we have the icon?  Or maybe
-                // build a Java cache for easy access.
-                notifyDownloadPaused(
-                        entry.id, entry.fileName, !entry.isOffTheRecord, false,
-                        entry.isOffTheRecord, entry.isTransient, null);
-                hideSummaryNotificationIfNecessary(-1);
-                return;
-            }
-        } else if (ACTION_DOWNLOAD_RESUME.equals(intent.getAction())) {
-            // If user manually resumes a download, update the network type if it
-            // is not metered previously.
-            boolean canDownloadWhileMetered = entry.canDownloadWhileMetered
-                    || DownloadManagerService.isActiveNetworkMetered(mContext);
-            // Update the SharedPreference entry.
-            mDownloadSharedPreferenceHelper.addOrReplaceSharedPreferenceEntry(
-                    new DownloadSharedPreferenceEntry(entry.id, entry.notificationId,
-                            entry.isOffTheRecord, canDownloadWhileMetered, entry.fileName, true,
-                            entry.isTransient));
-        } else if (ACTION_DOWNLOAD_RESUME_ALL.equals(intent.getAction())
-                && (mDownloadSharedPreferenceHelper.getEntries().isEmpty()
-                        || DownloadManagerService.hasDownloadManagerService())) {
-            hideSummaryNotificationIfNecessary(-1);
-            return;
-        } else if (ACTION_DOWNLOAD_OPEN.equals(intent.getAction())) {
-            // TODO(fgorski): Do we even need to do anything special here, before we launch Chrome?
-        } else if (ACTION_DOWNLOAD_CANCEL.equals(intent.getAction())
-                && IntentUtils.safeGetBooleanExtra(intent, EXTRA_NOTIFICATION_DISMISSED, false)) {
-            // User canceled a download by dismissing its notification from earlier versions, ignore
-            // it. TODO(qinmin): remove this else-if block after M60.
-            return;
-        }
-
-        BrowserParts parts = new EmptyBrowserParts() {
-            @Override
-            public void finishNativeInitialization() {
-                // Make sure the OfflineContentAggregator bridge is initialized.
-                OfflineContentAggregatorNotificationBridgeUiFactory.instance();
-
-                DownloadServiceDelegate downloadServiceDelegate =
-                        ACTION_DOWNLOAD_OPEN.equals(intent.getAction()) ? null
-                                                                        : getServiceDelegate(id);
-                if (ACTION_DOWNLOAD_CANCEL.equals(intent.getAction())) {
-                        // TODO(qinmin): Alternatively, we can delete the downloaded content on
-                        // SD card, and remove the download ID from the SharedPreferences so we
-                        // don't need to restart the browser process. http://crbug.com/579643.
-                        cancelNotification(entry.notificationId, entry.id);
-                        downloadServiceDelegate.cancelDownload(entry.id, entry.isOffTheRecord);
-                        for (Observer observer : mObservers) {
-                            observer.onDownloadCanceled(entry.id);
-                        }
-                } else if (ACTION_DOWNLOAD_PAUSE.equals(intent.getAction())) {
-                    // TODO(dtrainor): Consider hitting the delegate and rely on that to update the
-                    // state.
-                    notifyDownloadPaused(entry.id, entry.fileName, true, false,
+        switch (action) {
+            case ACTION_DOWNLOAD_PAUSE:
+                // If browser process already goes away, the download should have already paused. Do
+                // nothing in that case.
+                if (!DownloadManagerService.hasDownloadManagerService()) {
+                    // TODO(dtrainor): Should we spin up native to make sure we have the icon?  Or
+                    // maybe build a Java cache for easy access.
+                    notifyDownloadPaused(entry.id, entry.fileName, !entry.isOffTheRecord, false,
                             entry.isOffTheRecord, entry.isTransient, null);
-                    downloadServiceDelegate.pauseDownload(entry.id, entry.isOffTheRecord);
-                } else if (ACTION_DOWNLOAD_RESUME.equals(intent.getAction())) {
-                    // TODO(dtrainor): Consider hitting the delegate and rely on that to update the
-                    // state.
-                    notifyDownloadPending(entry.id, entry.fileName, entry.isOffTheRecord,
-                            entry.canDownloadWhileMetered, entry.isTransient, null);
-                    downloadServiceDelegate.resumeDownload(
-                            entry.id, entry.buildDownloadItem(), true);
-                } else if (ACTION_DOWNLOAD_RESUME_ALL.equals(intent.getAction())) {
-                        assert entry == null;
-                        resumeAllPendingDownloads();
-                } else if (ACTION_DOWNLOAD_OPEN.equals(intent.getAction())) {
-                    ContentId id = getContentIdFromIntent(intent);
-                    if (LegacyHelpers.isLegacyOfflinePage(id)) {
-                        OfflinePageDownloadBridge.openDownloadedPage(id);
-                    } else if (id != null) {
-                        OfflineContentAggregatorNotificationBridgeUiFactory.instance().openItem(id);
-                    }
-                } else {
-                        Log.e(TAG, "Unrecognized intent action.", intent);
-                }
-                if (!ACTION_DOWNLOAD_OPEN.equals(intent.getAction())) {
-                    downloadServiceDelegate.destroyServiceDelegate();
+                    hideSummaryNotificationIfNecessary(-1);
+                    return;
                 }
 
-                hideSummaryNotificationIfNecessary(ACTION_DOWNLOAD_CANCEL.equals(intent.getAction())
-                                ? entry.notificationId
-                                : -1);
-            }
-        };
-        try {
-            ChromeBrowserInitializer.getInstance(mContext).handlePreNativeStartup(parts);
-            ChromeBrowserInitializer.getInstance(mContext).handlePostNativeStartup(true, parts);
-        } catch (ProcessInitException e) {
-            Log.e(TAG, "Unable to load native library.", e);
-            ChromeApplication.reportStartupErrorAndExit(e);
+                // TODO(dtrainor): Consider hitting the delegate and rely on that to update the
+                // state.
+                notifyDownloadPaused(entry.id, entry.fileName, true, false, entry.isOffTheRecord,
+                        entry.isTransient, null);
+                mDownloadBroadcastManager.onNotificationInteraction(mContext, intent);
+                break;
+
+            case ACTION_DOWNLOAD_RESUME:
+                // If user manually resumes a download, update the network type if it
+                // is not metered previously.
+                boolean canDownloadWhileMetered = entry.canDownloadWhileMetered
+                        || DownloadManagerService.isActiveNetworkMetered(mContext);
+                // Update the SharedPreference entry.
+                mDownloadSharedPreferenceHelper.addOrReplaceSharedPreferenceEntry(
+                        new DownloadSharedPreferenceEntry(entry.id, entry.notificationId,
+                                entry.isOffTheRecord, canDownloadWhileMetered, entry.fileName, true,
+                                entry.isTransient));
+
+                // TODO(dtrainor): Consider hitting the delegate and rely on that to update the
+                // state.
+                notifyDownloadPending(entry.id, entry.fileName, entry.isOffTheRecord,
+                        entry.canDownloadWhileMetered, entry.isTransient, null);
+                mDownloadBroadcastManager.onNotificationInteraction(mContext, intent);
+                break;
+
+            case ACTION_DOWNLOAD_RESUME_ALL:
+                if (mDownloadSharedPreferenceHelper.getEntries().isEmpty()
+                        || DownloadManagerService.hasDownloadManagerService()) {
+                    hideSummaryNotificationIfNecessary(-1);
+                    return;
+                }
+                resumeAllPendingDownloads();
+                break;
+
+            case ACTION_DOWNLOAD_OPEN:
+                // TODO(fgorski): Do we even need to do anything special before we launch Chrome?
+                mDownloadBroadcastManager.onNotificationInteraction(mContext, intent);
+                break;
+
+            case ACTION_DOWNLOAD_CANCEL:
+                if (IntentUtils.safeGetBooleanExtra(intent, EXTRA_NOTIFICATION_DISMISSED, false)) {
+                    // User canceled a download by dismissing its notification from earlier
+                    // versions, ignore it. TODO(qinmin): remove this else-if block after M60.
+                    return;
+                }
+                // TODO(jming): Potential condition if cancelNotification deletes the shared
+                // preference entry before this gets called.
+                mDownloadBroadcastManager.onNotificationInteraction(mContext, intent);
+
+                // TODO(qinmin): Alternatively, we can delete the downloaded content on
+                // SD card, and remove the download ID from the SharedPreferences so we
+                // don't need to restart the browser process. http://crbug.com/579643.
+                for (Observer observer : mObservers) {
+                    observer.onDownloadCanceled(entry.id);
+                }
+                cancelNotification(entry.notificationId, entry.id);
+                break;
+
+            default:
+                Log.e(TAG, "Unrecognized intent action.", intent);
+                break;
         }
-    }
 
-    /**
-     * Handles operations for downloads that the DownloadNotificationService is unaware of.
-     *
-     * This can happen because the DownloadNotificationService learn about downloads later than
-     * Download Home does, and may not yet have a DownloadSharedPreferenceEntry for the item.
-     *
-     * TODO(qinmin): Figure out how to fix the SharedPreferences so that it properly tracks entries.
-     */
-    private void handleDownloadOperationForMissingNotification(Intent intent) {
-        // This function should only be called via Download Home, but catch this case to be safe.
-        if (!DownloadManagerService.hasDownloadManagerService()) return;
-
-        String action = intent.getAction();
-        ContentId id = getContentIdFromIntent(intent);
-        boolean isOffTheRecord =
-                IntentUtils.safeGetBooleanExtra(intent, EXTRA_IS_OFF_THE_RECORD, false);
-        if (!LegacyHelpers.isLegacyDownload(id)) return;
-
-        // Pass information directly to the DownloadManagerService.
-        if (TextUtils.equals(action, ACTION_DOWNLOAD_CANCEL)) {
-            getServiceDelegate(id).cancelDownload(id, isOffTheRecord);
-        } else if (TextUtils.equals(action, ACTION_DOWNLOAD_PAUSE)) {
-            getServiceDelegate(id).pauseDownload(id, isOffTheRecord);
-        } else if (TextUtils.equals(action, ACTION_DOWNLOAD_RESUME)) {
-            DownloadInfo info = new DownloadInfo.Builder()
-                                        .setDownloadGuid(id.id)
-                                        .setIsOffTheRecord(isOffTheRecord)
-                                        .build();
-            getServiceDelegate(id).resumeDownload(id, new DownloadItem(false, info), true);
-        }
+        hideSummaryNotificationIfNecessary(
+                ACTION_DOWNLOAD_CANCEL.equals(intent.getAction()) ? entry.notificationId : -1);
     }
 
     /**
@@ -1141,7 +1080,7 @@
      * @param id The {@link ContentId} to grab the delegate for.
      * @return delegate for interactions with the entry
      */
-    DownloadServiceDelegate getServiceDelegate(ContentId id) {
+    static DownloadServiceDelegate getServiceDelegate(ContentId id) {
         if (LegacyHelpers.isLegacyOfflinePage(id)) {
             return OfflinePageDownloadBridge.getDownloadServiceDelegate();
         }
@@ -1202,7 +1141,7 @@
         return true;
     }
 
-    private static boolean canResumeDownload(Context context, DownloadSharedPreferenceEntry entry) {
+    static boolean canResumeDownload(Context context, DownloadSharedPreferenceEntry entry) {
         if (entry == null) return false;
         if (!entry.isAutoResumable) return false;
 
@@ -1231,7 +1170,6 @@
      * already in progress, do nothing.
      */
     public void resumeAllPendingDownloads() {
-        if (!DownloadManagerService.hasDownloadManagerService()) return;
         List<DownloadSharedPreferenceEntry> entries = mDownloadSharedPreferenceHelper.getEntries();
         for (int i = 0; i < entries.size(); ++i) {
             DownloadSharedPreferenceEntry entry = entries.get(i);
@@ -1240,9 +1178,14 @@
 
             notifyDownloadPending(entry.id, entry.fileName, entry.isOffTheRecord,
                     entry.canDownloadWhileMetered, entry.isTransient, null);
-            DownloadServiceDelegate downloadServiceDelegate = getServiceDelegate(entry.id);
-            downloadServiceDelegate.resumeDownload(entry.id, entry.buildDownloadItem(), false);
-            downloadServiceDelegate.destroyServiceDelegate();
+
+            // TODO(jming): Move this to DownloadBroadcastManager eventually.
+            Intent intent = new Intent();
+            intent.setAction(ACTION_DOWNLOAD_RESUME);
+            intent.putExtra(EXTRA_DOWNLOAD_CONTENTID_ID, entry.id.id);
+            intent.putExtra(EXTRA_DOWNLOAD_CONTENTID_NAMESPACE, entry.id.namespace);
+
+            mDownloadBroadcastManager.onNotificationInteraction(mContext, intent);
         }
     }
 

chrome/android/java/src/org/chromium/chrome/browser/tab/Tab.java

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/tab/Tab.java b/chrome/android/java/src/org/chromium/chrome/browser/tab/Tab.java
index 5d64948..134f6907 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/tab/Tab.java
+++ b/chrome/android/java/src/org/chromium/chrome/browser/tab/Tab.java
@@ -1020,6 +1020,7 @@
     /**
      * @return Whether or not the {@link Tab} represents a {@link NativePage}.
      */
+    @CalledByNative
     public boolean isNativePage() {
         return mNativePage != null;
     }

chrome/android/java/src/org/chromium/chrome/browser/vr_shell/VrShellImpl.java

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/vr_shell/VrShellImpl.java b/chrome/android/java/src/org/chromium/chrome/browser/vr_shell/VrShellImpl.java
index 5c7157d..d142610 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/vr_shell/VrShellImpl.java
+++ b/chrome/android/java/src/org/chromium/chrome/browser/vr_shell/VrShellImpl.java
@@ -214,9 +214,9 @@
                     // We need the CVC to think it has Window Focus so it doesn't blur the page,
                     // even though we're drawing VR layouts over top of it.
                     mContentViewCore.onWindowFocusChanged(true);
-                    nativeSwapContents(mNativeVrShell, mContentViewCore.getWebContents(), null);
+                    nativeSwapContents(mNativeVrShell, tab, null);
                 } else {
-                    nativeSwapContents(mNativeVrShell, null, mAndroidUiGestureTarget);
+                    nativeSwapContents(mNativeVrShell, tab, mAndroidUiGestureTarget);
                 }
                 updateHistoryButtonsVisibility();
             }
@@ -771,8 +771,8 @@
             boolean reprojectedRendering);
     private native void nativeSetSurface(long nativeVrShell, Surface surface);
     private native void nativeSetSplashScreenIcon(long nativeVrShell, Bitmap bitmap);
-    private native void nativeSwapContents(long nativeVrShell, WebContents webContents,
-            AndroidUiGestureTarget androidUiGestureTarget);
+    private native void nativeSwapContents(
+            long nativeVrShell, Tab tab, AndroidUiGestureTarget androidUiGestureTarget);
     private native void nativeDestroy(long nativeVrShell);
     private native void nativeOnTriggerEvent(long nativeVrShell, boolean touched);
     private native void nativeOnPause(long nativeVrShell);

chrome/android/java/src/org/chromium/chrome/browser/webapps/WebappDataStorage.java

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/webapps/WebappDataStorage.java b/chrome/android/java/src/org/chromium/chrome/browser/webapps/WebappDataStorage.java
index 05b469b0..49d4586e 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/webapps/WebappDataStorage.java
+++ b/chrome/android/java/src/org/chromium/chrome/browser/webapps/WebappDataStorage.java
@@ -351,6 +351,11 @@
         mPreferences.edit().putInt(KEY_SOURCE, source).apply();
     }
 
+    /** Returns the id stored in this object. */
+    public String getId() {
+        return mId;
+    }
+
     /**
      * Returns the last used time of this object, or -1 if it is not stored.
      */

chrome/android/java/src/org/chromium/chrome/browser/webapps/WebappRegistry.java

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/webapps/WebappRegistry.java b/chrome/android/java/src/org/chromium/chrome/browser/webapps/WebappRegistry.java
index 36777a62..b28997fc 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/webapps/WebappRegistry.java
+++ b/chrome/android/java/src/org/chromium/chrome/browser/webapps/WebappRegistry.java
@@ -148,6 +148,7 @@
      * Returns the WebappDataStorage object whose scope most closely matches the provided URL, or
      * null if a matching web app cannot be found. The most closely matching scope is the longest
      * scope which has the same prefix as the URL to open.
+     * Note: this function skips any storage object associated with WebAPKs.
      * @param url The URL to search for.
      * @return The storage object for the web app, or null if one cannot be found.
      */
@@ -156,6 +157,8 @@
         int largestOverlap = 0;
         for (HashMap.Entry<String, WebappDataStorage> entry : mStorages.entrySet()) {
             WebappDataStorage storage = entry.getValue();
+            if (storage.getId().startsWith(WebApkConstants.WEBAPK_ID_PREFIX)) continue;
+
             String scope = storage.getScope();
             if (url.startsWith(scope) && scope.length() > largestOverlap) {
                 bestMatch = storage;

chrome/android/java/strings/android_chrome_strings.grd

diff --git a/chrome/android/java/strings/android_chrome_strings.grd b/chrome/android/java/strings/android_chrome_strings.grd
index 94356ff1e..5c458328 100644
--- a/chrome/android/java/strings/android_chrome_strings.grd
+++ b/chrome/android/java/strings/android_chrome_strings.grd
@@ -2559,13 +2559,13 @@
       </message>
 
       <!-- Omnibox Placeholder Experiment -->
-      <message name="IDS_SEARCH_OR_TYPE_WEB_ADDRESS" desc="Prompt to enter text into the text field that will either perform web searches or navigate to a website. [CHAR-LIMIT=38]">
+      <message name="IDS_SEARCH_OR_TYPE_WEB_ADDRESS" desc="Prompt to enter text into the text field that will either perform web searches or navigate to a website.">
         Search or type web address
       </message>
-      <message name="IDS_TYPE_WHAT_YOU_ARE_LOOKING_FOR" desc="Prompt to enter what user is looking for into the text field that will either perform web searches or navigate to a website. [CHAR-LIMIT=38]">
+      <message name="IDS_TYPE_WHAT_YOU_ARE_LOOKING_FOR" desc="Prompt to enter what user is looking for into the text field that will either perform web searches or navigate to a website.">
         Type what you’re looking for
       </message>
-      <message name="IDS_FIND_NEWS_RECIPES_WEATHER" desc="Prompt to enter text into the text field that will either perform web searches or navigate to a website, with suggestions of finding news, recipes or weather. [CHAR-LIMIT=38]">
+      <message name="IDS_FIND_NEWS_RECIPES_WEATHER" desc="Prompt to enter text into the text field that will either perform web searches or navigate to a website, with suggestions of finding news, recipes or weather.">
          Find news, recipes, weather...
       </message>
 

chrome/android/java_sources.gni

diff --git a/chrome/android/java_sources.gni b/chrome/android/java_sources.gni
index 9c2c92f..15ba4fa2 100644
--- a/chrome/android/java_sources.gni
+++ b/chrome/android/java_sources.gni
@@ -324,6 +324,7 @@
   "java/src/org/chromium/chrome/browser/dom_distiller/ReaderModeTabInfo.java",
   "java/src/org/chromium/chrome/browser/download/ChromeDownloadDelegate.java",
   "java/src/org/chromium/chrome/browser/download/DownloadActivity.java",
+  "java/src/org/chromium/chrome/browser/download/DownloadBroadcastManager.java",
   "java/src/org/chromium/chrome/browser/download/DownloadBroadcastReceiver.java",
   "java/src/org/chromium/chrome/browser/download/DownloadController.java",
   "java/src/org/chromium/chrome/browser/download/DownloadInfo.java",

chrome/android/javatests/src/org/chromium/chrome/browser/download/DownloadNotificationServiceTest.java

diff --git a/chrome/android/javatests/src/org/chromium/chrome/browser/download/DownloadNotificationServiceTest.java b/chrome/android/javatests/src/org/chromium/chrome/browser/download/DownloadNotificationServiceTest.java
index abb6586..7dc58c7 100644
--- a/chrome/android/javatests/src/org/chromium/chrome/browser/download/DownloadNotificationServiceTest.java
+++ b/chrome/android/javatests/src/org/chromium/chrome/browser/download/DownloadNotificationServiceTest.java
@@ -34,6 +34,17 @@
  */
 public class DownloadNotificationServiceTest extends
         ServiceTestCase<MockDownloadNotificationService> {
+    /**
+     * Implementation of DownloadBroadcastManager that skips loading the native to just propagate
+     * interactions through for testing purposes.
+     */
+    private static class MockDownloadBroadcastManager extends DownloadBroadcastManager {
+        @Override
+        void loadNativeAndPropagateInteraction(Context context, Intent intent) {
+            // Skip loading the native and just propagate interaction.
+            propagateInteraction(intent);
+        }
+    }
 
     private static class MockDownloadManagerService extends DownloadManagerService {
         final List<DownloadItem> mDownloads = new ArrayList<DownloadItem>();
@@ -352,6 +363,7 @@
         ThreadUtils.runOnUiThreadBlocking(
                 (Runnable) () -> DownloadManagerService.setDownloadManagerService(manager));
         DownloadManagerService.setIsNetworkMeteredForTest(true);
+        service.setDownloadBroadcastManager(new MockDownloadBroadcastManager());
         resumeAllDownloads(service);
         assertEquals(1, manager.mDownloads.size());
         assertEquals(manager.mDownloads.get(0).getDownloadInfo().getDownloadGuid(), guid2);

chrome/android/javatests/src/org/chromium/chrome/browser/download/MockDownloadNotificationService.java

diff --git a/chrome/android/javatests/src/org/chromium/chrome/browser/download/MockDownloadNotificationService.java b/chrome/android/javatests/src/org/chromium/chrome/browser/download/MockDownloadNotificationService.java
index 1add6f5..ed88ca0 100644
--- a/chrome/android/javatests/src/org/chromium/chrome/browser/download/MockDownloadNotificationService.java
+++ b/chrome/android/javatests/src/org/chromium/chrome/browser/download/MockDownloadNotificationService.java
@@ -7,7 +7,6 @@
 import android.app.Notification;
 import android.content.Context;
 import android.graphics.Bitmap;
-import android.util.Pair;
 
 import org.chromium.base.ThreadUtils;
 import org.chromium.components.offline_items_collection.ContentId;
@@ -57,10 +56,6 @@
     }
 
     @Override
-    void updateSummaryIconInternal(
-            int removedNotificationId, Pair<Integer, Notification> addedNotification) {}
-
-    @Override
     void cancelSummaryNotification() {}
 
     @Override

chrome/android/junit/src/org/chromium/chrome/browser/webapps/WebappRegistryTest.java

diff --git a/chrome/android/junit/src/org/chromium/chrome/browser/webapps/WebappRegistryTest.java b/chrome/android/junit/src/org/chromium/chrome/browser/webapps/WebappRegistryTest.java
index f913ea38..8ceb76d 100644
--- a/chrome/android/junit/src/org/chromium/chrome/browser/webapps/WebappRegistryTest.java
+++ b/chrome/android/junit/src/org/chromium/chrome/browser/webapps/WebappRegistryTest.java
@@ -5,6 +5,7 @@
 package org.chromium.chrome.browser.webapps;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 
 import android.content.Context;
@@ -48,6 +49,8 @@
     private static final String KEY_WEBAPP_SET = "webapp_set";
     private static final String KEY_LAST_CLEANUP = "last_cleanup";
 
+    private static final String START_URL = "https://foo.com";
+
     private static final int INITIAL_TIME = 0;
 
     private SharedPreferences mSharedPreferences;
@@ -325,13 +328,13 @@
         String webappId2 = WebApkConstants.WEBAPK_ID_PREFIX + "uninstalledWebApk2";
         String webApkPackage2 = "uninstalledWebApk2";
 
-        FetchStorageCallback storageCallback1 = new FetchStorageCallback(
-                createWebApkIntent(webappId1, webApkPackage1));
+        FetchStorageCallback storageCallback1 =
+                new FetchStorageCallback(createWebApkIntent(webappId1, START_URL, webApkPackage1));
         registerWebapp(webappId1, storageCallback1);
         assertTrue(storageCallback1.getCallbackCalled());
 
-        FetchStorageCallback storageCallback2 = new FetchStorageCallback(
-                createWebApkIntent(webappId1, webApkPackage2));
+        FetchStorageCallback storageCallback2 =
+                new FetchStorageCallback(createWebApkIntent(webappId1, START_URL, webApkPackage2));
         registerWebapp(webappId2, storageCallback2);
         assertTrue(storageCallback2.getCallbackCalled());
 
@@ -363,13 +366,13 @@
         String uninstalledWebappId = WebApkConstants.WEBAPK_ID_PREFIX + "uninstalledWebApk";
         String uninstalledWebApkPackage = "uninstalledWebApk";
 
-        FetchStorageCallback storageCallback = new FetchStorageCallback(
-                createWebApkIntent(webappId, webApkPackage));
+        FetchStorageCallback storageCallback =
+                new FetchStorageCallback(createWebApkIntent(webappId, START_URL, webApkPackage));
         registerWebapp(webappId, storageCallback);
         assertTrue(storageCallback.getCallbackCalled());
 
         FetchStorageCallback storageCallback2 = new FetchStorageCallback(
-                createWebApkIntent(uninstalledWebappId, uninstalledWebApkPackage));
+                createWebApkIntent(uninstalledWebappId, START_URL, uninstalledWebApkPackage));
         registerWebapp(uninstalledWebappId, storageCallback2);
         assertTrue(storageCallback2.getCallbackCalled());
 
@@ -404,13 +407,13 @@
         String webApkPackage = "installedWebApk";
         String installedWebappId = WebApkConstants.WEBAPK_ID_PREFIX + "installedWebApk";
 
-        FetchStorageCallback storageCallback =
-                new FetchStorageCallback(createWebApkIntent(deprecatedWebappId, webApkPackage));
+        FetchStorageCallback storageCallback = new FetchStorageCallback(
+                createWebApkIntent(deprecatedWebappId, START_URL, webApkPackage));
         registerWebapp(deprecatedWebappId, storageCallback);
         assertTrue(storageCallback.getCallbackCalled());
 
-        FetchStorageCallback storageCallback2 =
-                new FetchStorageCallback(createWebApkIntent(installedWebappId, webApkPackage));
+        FetchStorageCallback storageCallback2 = new FetchStorageCallback(
+                createWebApkIntent(installedWebappId, START_URL, webApkPackage));
         registerWebapp(installedWebappId, storageCallback2);
         assertTrue(storageCallback2.getCallbackCalled());
 
@@ -642,6 +645,31 @@
         assertEquals(null, storage6);
     }
 
+    @Test
+    @Feature({"WebApk"})
+    public void testGetWebappDataStorageForUrlWithWebApk() throws Exception {
+        final String startUrl = START_URL;
+        final String testUrl = START_URL + "/index.html";
+
+        String webApkId = WebApkConstants.WEBAPK_ID_PREFIX + "WebApk";
+        registerWebapp(webApkId,
+                new FetchStorageCallback(
+                        createWebApkIntent(webApkId, startUrl, "org.chromium.webapk")));
+
+        // testUrl should return null.
+        WebappDataStorage storage1 =
+                WebappRegistry.getInstance().getWebappDataStorageForUrl(testUrl);
+        assertNull(storage1);
+
+        String webappId = "webapp";
+        registerWebapp(webappId, new FetchStorageCallback(createShortcutIntent(startUrl)));
+
+        // testUrl should return the webapp.
+        WebappDataStorage storage2 =
+                WebappRegistry.getInstance().getWebappDataStorageForUrl(testUrl);
+        assertEquals(webappId, storage2.getId());
+    }
+
     private Set<String> addWebappsToRegistry(String... webapps) {
         final Set<String> expected = new HashSet<>(Arrays.asList(webapps));
         mSharedPreferences.edit().putStringSet(WebappRegistry.KEY_WEBAPP_SET, expected).apply();
@@ -657,10 +685,10 @@
         return ShortcutHelper.createWebappShortcutIntentForTesting("id", url);
     }
 
-    private Intent createWebApkIntent(String webappId, String webApkPackage) {
+    private Intent createWebApkIntent(String webappId, String url, String webApkPackage) {
         Intent intent = new Intent();
         intent.putExtra(ShortcutHelper.EXTRA_ID, webappId)
-                .putExtra(ShortcutHelper.EXTRA_URL, "https://foo.com")
+                .putExtra(ShortcutHelper.EXTRA_URL, url)
                 .putExtra(WebApkConstants.EXTRA_WEBAPK_PACKAGE_NAME, webApkPackage);
         return intent;
     }

chrome/app/theme/default_100_percent/common/infobar_media_stream_camera.png

diff --git a/chrome/app/theme/default_100_percent/common/infobar_media_stream_camera.png b/chrome/app/theme/default_100_percent/common/infobar_media_stream_camera.png
deleted file mode 100644
index d62f8e41..0000000
--- a/chrome/app/theme/default_100_percent/common/infobar_media_stream_camera.png
+++ /dev/null
Binary files differ

chrome/app/theme/default_100_percent/common/infobar_media_stream_mic.png

diff --git a/chrome/app/theme/default_100_percent/common/infobar_media_stream_mic.png b/chrome/app/theme/default_100_percent/common/infobar_media_stream_mic.png
deleted file mode 100644
index 14460da..0000000
--- a/chrome/app/theme/default_100_percent/common/infobar_media_stream_mic.png
+++ /dev/null
Binary files differ

chrome/app/theme/default_100_percent/common/infobar_save_password.png

diff --git a/chrome/app/theme/default_100_percent/common/infobar_save_password.png b/chrome/app/theme/default_100_percent/common/infobar_save_password.png
deleted file mode 100644
index 1b1340e40..0000000
--- a/chrome/app/theme/default_100_percent/common/infobar_save_password.png
+++ /dev/null
Binary files differ

chrome/app/theme/default_200_percent/common/infobar_media_stream_camera.png

diff --git a/chrome/app/theme/default_200_percent/common/infobar_media_stream_camera.png b/chrome/app/theme/default_200_percent/common/infobar_media_stream_camera.png
deleted file mode 100644
index 186a2f3..0000000
--- a/chrome/app/theme/default_200_percent/common/infobar_media_stream_camera.png
+++ /dev/null
Binary files differ

chrome/app/theme/default_200_percent/common/infobar_media_stream_mic.png

diff --git a/chrome/app/theme/default_200_percent/common/infobar_media_stream_mic.png b/chrome/app/theme/default_200_percent/common/infobar_media_stream_mic.png
deleted file mode 100644
index 107d61e..0000000
--- a/chrome/app/theme/default_200_percent/common/infobar_media_stream_mic.png
+++ /dev/null
Binary files differ

chrome/app/theme/default_200_percent/common/infobar_save_password.png

diff --git a/chrome/app/theme/default_200_percent/common/infobar_save_password.png b/chrome/app/theme/default_200_percent/common/infobar_save_password.png
deleted file mode 100644
index ede1f4f..0000000
--- a/chrome/app/theme/default_200_percent/common/infobar_save_password.png
+++ /dev/null
Binary files differ

chrome/app/theme/theme_resources.grd

diff --git a/chrome/app/theme/theme_resources.grd b/chrome/app/theme/theme_resources.grd
index b44d0a9..fd164d8 100644
--- a/chrome/app/theme/theme_resources.grd
+++ b/chrome/app/theme/theme_resources.grd
@@ -218,11 +218,6 @@
         <structure type="chrome_scaled_image" name="IDR_INFO" file="legacy/info_small.png" />
       </if>
       <structure type="chrome_scaled_image" name="IDR_INFOBAR_3D_BLOCKED" file="common/infobar_3d_blocked.png" />
-      <structure type="chrome_scaled_image" name="IDR_INFOBAR_MEDIA_STREAM_CAMERA" file="common/infobar_media_stream_camera.png" />
-      <structure type="chrome_scaled_image" name="IDR_INFOBAR_MEDIA_STREAM_MIC" file="common/infobar_media_stream_mic.png" />
-      <if expr="is_android">
-        <structure type="chrome_scaled_image" name="IDR_INFOBAR_SAVE_PASSWORD" file="common/infobar_save_password.png" />
-      </if>
       <if expr="is_macosx or is_android">
         <structure type="chrome_scaled_image" name="IDR_INFOBAR_TRANSLATE" file="common/infobar_translate.png" />
       </if>

chrome/browser/android/resource_id.h

diff --git a/chrome/browser/android/resource_id.h b/chrome/browser/android/resource_id.h
index 0dfcf07..10614ad 100644
--- a/chrome/browser/android/resource_id.h
+++ b/chrome/browser/android/resource_id.h
@@ -20,9 +20,6 @@
 // InfoBar resources.
 LINK_RESOURCE_ID(IDR_INFOBAR_3D_BLOCKED, R.drawable.infobar_3d_blocked)
 LINK_RESOURCE_ID(IDR_INFOBAR_AUTOFILL_CC, R.drawable.infobar_autofill_cc)
-LINK_RESOURCE_ID(IDR_INFOBAR_MEDIA_STREAM_CAMERA, R.drawable.infobar_camera)
-LINK_RESOURCE_ID(IDR_INFOBAR_MEDIA_STREAM_MIC, R.drawable.infobar_microphone)
-LINK_RESOURCE_ID(IDR_INFOBAR_SAVE_PASSWORD, R.drawable.infobar_savepassword)
 LINK_RESOURCE_ID(IDR_INFOBAR_TRANSLATE, R.drawable.infobar_translate)
 LINK_RESOURCE_ID(IDR_BLOCKED_POPUPS, R.drawable.infobar_blocked_popups)
 
@@ -30,6 +27,10 @@
 DECLARE_RESOURCE_ID(IDR_ANDROID_INFOBAR_FROZEN_TAB, R.drawable.infobar_restore)
 DECLARE_RESOURCE_ID(IDR_ANDROID_INFOBAR_GEOLOCATION,
                     R.drawable.infobar_geolocation)
+DECLARE_RESOURCE_ID(IDR_ANDROID_INFOBAR_MEDIA_STREAM_CAMERA,
+                    R.drawable.infobar_camera)
+DECLARE_RESOURCE_ID(IDR_ANDROID_INFOBAR_MEDIA_STREAM_MIC,
+                    R.drawable.infobar_microphone)
 DECLARE_RESOURCE_ID(IDR_ANDROID_INFOBAR_MEDIA_STREAM_SCREEN,
                     R.drawable.infobar_screen_share)
 DECLARE_RESOURCE_ID(IDR_ANDROID_INFOBAR_MIDI, R.drawable.infobar_midi)
@@ -41,6 +42,8 @@
                     R.drawable.infobar_chrome)
 DECLARE_RESOURCE_ID(IDR_ANDROID_INFOBAR_PROTECTED_MEDIA_IDENTIFIER,
                     R.drawable.infobar_protected_media_identifier)
+DECLARE_RESOURCE_ID(IDR_ANDROID_INFOBAR_SAVE_PASSWORD,
+                    R.drawable.infobar_savepassword)
 DECLARE_RESOURCE_ID(IDR_ANDROID_INFOBAR_SUBRESOURCE_FILTERING,
                     R.drawable.infobar_chrome)
 DECLARE_RESOURCE_ID(IDR_ANDROID_INFOBAR_WARNING, R.drawable.infobar_warning)
@@ -54,7 +57,8 @@
 DECLARE_RESOURCE_ID(IDR_PAGEINFO_BAD, R.drawable.pageinfo_bad)
 // Should never occur, use warning just in case:
 // Enterprise managed: ChromeOS only.
-DECLARE_RESOURCE_ID(IDR_PAGEINFO_ENTERPRISE_MANAGED, R.drawable.pageinfo_warning)
+DECLARE_RESOURCE_ID(IDR_PAGEINFO_ENTERPRISE_MANAGED,
+                    R.drawable.pageinfo_warning)
 // Info: Only shown on chrome:// urls, which don't show the connection info
 // popup.
 DECLARE_RESOURCE_ID(IDR_PAGEINFO_INFO, R.drawable.pageinfo_warning)

chrome/browser/android/tab_android.cc

diff --git a/chrome/browser/android/tab_android.cc b/chrome/browser/android/tab_android.cc
index 3dd7f6b..b5e58b4 100644
--- a/chrome/browser/android/tab_android.cc
+++ b/chrome/browser/android/tab_android.cc
@@ -162,6 +162,11 @@
       Java_Tab_getTitle(env, weak_java_tab_.get(env)));
 }
 
+bool TabAndroid::IsNativePage() const {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  return Java_Tab_isNativePage(env, weak_java_tab_.get(env));
+}
+
 GURL TabAndroid::GetURL() const {
   JNIEnv* env = base::android::AttachCurrentThread();
   return GURL(base::android::ConvertJavaStringToUTF8(

chrome/browser/android/tab_android.h

diff --git a/chrome/browser/android/tab_android.h b/chrome/browser/android/tab_android.h
index 6ef594e..b9e4a87 100644
--- a/chrome/browser/android/tab_android.h
+++ b/chrome/browser/android/tab_android.h
@@ -91,6 +91,7 @@
 
   int GetAndroidId() const;
   int GetSyncId() const;
+  bool IsNativePage() const;
 
   // Return the tab title.
   base::string16 GetTitle() const;

chrome/browser/android/vr_shell/vr_shell.cc

diff --git a/chrome/browser/android/vr_shell/vr_shell.cc b/chrome/browser/android/vr_shell/vr_shell.cc
index 87382d21..e7f3cd1 100644
--- a/chrome/browser/android/vr_shell/vr_shell.cc
+++ b/chrome/browser/android/vr_shell/vr_shell.cc
@@ -19,7 +19,6 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
-#include "chrome/browser/android/tab_android.h"
 #include "chrome/browser/android/vr_shell/android_ui_gesture_target.h"
 #include "chrome/browser/android/vr_shell/vr_compositor.h"
 #include "chrome/browser/android/vr_shell/vr_gl_thread.h"
@@ -142,25 +141,32 @@
 void VrShell::SwapContents(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
-    const JavaParamRef<jobject>& web_contents,
+    const JavaParamRef<jobject>& tab,
     const JavaParamRef<jobject>& android_ui_gesture_target) {
-  content::WebContents* contents = nullptr;
+  DCHECK(tab.obj());
+  TabAndroid* active_tab =
+      TabAndroid::GetNativeTab(env, JavaParamRef<jobject>(env, tab));
+  DCHECK(active_tab);
+  content::WebContents* active_web_contents =
+      active_tab->IsNativePage() ? nullptr : active_tab->web_contents();
+  auto* last_active_web_contents = GetActiveWebContents();
+
+  if (active_web_contents && active_web_contents == last_active_web_contents)
+    return;
+
   AndroidUiGestureTarget* target = nullptr;
-  if (web_contents.obj()) {
-    contents = content::WebContents::FromJavaWebContents(web_contents);
-    if (contents == web_contents_)
-      return;
-  } else {
+  if (!active_web_contents) {
     DCHECK(!android_ui_gesture_target.is_null());
     target = AndroidUiGestureTarget::FromJavaObject(android_ui_gesture_target);
     if (target == android_ui_gesture_target_.get())
       return;
   }
 
-  SetIsInVR(web_contents_, false);
-  web_contents_ = contents;
-  compositor_->SetLayer(web_contents_);
-  SetIsInVR(web_contents_, true);
+  SetIsInVR(last_active_web_contents, false);
+
+  active_tab_ = active_tab;
+  compositor_->SetLayer(active_web_contents);
+  SetIsInVR(active_web_contents, true);
   ContentFrameWasResized(false /* unused */);
   SetUiState();
 
@@ -171,12 +177,12 @@
     metrics_helper_ = nullptr;
     return;
   }
-  input_manager_ = base::MakeUnique<VrInputManager>(web_contents_);
+  input_manager_ = base::MakeUnique<VrInputManager>(active_web_contents);
   vr_web_contents_observer_ = base::MakeUnique<VrWebContentsObserver>(
-      web_contents_, this, ui_, toolbar_.get());
+      active_web_contents, this, ui_, toolbar_.get());
   // TODO(billorr): Make VrMetricsHelper tab-aware and able to track multiple
   // tabs. crbug.com/684661
-  metrics_helper_ = base::MakeUnique<VrMetricsHelper>(web_contents_);
+  metrics_helper_ = base::MakeUnique<VrMetricsHelper>(active_web_contents);
   metrics_helper_->SetVRActive(true);
   metrics_helper_->SetWebVREnabled(webvr_mode_);
 }
@@ -184,14 +190,20 @@
 void VrShell::SetUiState() {
   toolbar_->Update();
 
-  if (!web_contents_) {
+  auto* active_web_contents = GetActiveWebContents();
+
+  if (!active_web_contents) {
     ui_->SetLoading(false);
     ui_->SetFullscreen(false);
-    ui_->SetIncognito(false);
   } else {
-    ui_->SetLoading(web_contents_->IsLoading());
-    ui_->SetFullscreen(web_contents_->IsFullscreen());
-    ui_->SetIncognito(web_contents_->GetBrowserContext()->IsOffTheRecord());
+    ui_->SetLoading(active_web_contents->IsLoading());
+    ui_->SetFullscreen(active_web_contents->IsFullscreen());
+  }
+  if (active_tab_) {
+    ui_->SetIncognito(
+        active_tab_->web_contents()->GetBrowserContext()->IsOffTheRecord());
+  } else {
+    ui_->SetIncognito(false);
   }
 }
 
@@ -321,7 +333,7 @@
   // exit vr session
   if (metrics_helper_)
     metrics_helper_->SetVRActive(false);
-  SetIsInVR(web_contents_, false);
+  SetIsInVR(GetActiveWebContents(), false);
 }
 
 void VrShell::OnResume(JNIEnv* env, const JavaParamRef<jobject>& obj) {
@@ -331,7 +343,7 @@
 
   if (metrics_helper_)
     metrics_helper_->SetVRActive(true);
-  SetIsInVR(web_contents_, true);
+  SetIsInVR(GetActiveWebContents(), true);
 }
 
 void VrShell::SetSurface(JNIEnv* env,
@@ -563,7 +575,7 @@
 
 void VrShell::ContentWebContentsDestroyed() {
   input_manager_.reset();
-  web_contents_ = nullptr;
+  active_tab_ = nullptr;
   // TODO(mthiesse): Handle web contents being destroyed.
   ForceExitVr();
 }
@@ -574,8 +586,10 @@
 }
 
 void VrShell::ContentWasShown() {
-  if (web_contents_)
-    input_manager_ = base::MakeUnique<VrInputManager>(web_contents_);
+  auto* active_web_contents = GetActiveWebContents();
+  if (active_web_contents) {
+    input_manager_ = base::MakeUnique<VrInputManager>(active_web_contents);
+  }
 }
 
 void VrShell::ForceExitVr() {
@@ -588,8 +602,9 @@
 }
 
 void VrShell::ExitFullscreen() {
-  if (web_contents_ && web_contents_->IsFullscreen()) {
-    web_contents_->ExitFullscreen(false);
+  auto* active_web_contents = GetActiveWebContents();
+  if (active_web_contents && active_web_contents->IsFullscreen()) {
+    active_web_contents->ExitFullscreen(false);
   }
 }
 
@@ -780,7 +795,10 @@
 }
 
 content::WebContents* VrShell::GetActiveWebContents() const {
-  return web_contents_;
+  // TODO(tiborg): Handle the case when Tab#isShowingErrorPage returns true.
+  return (active_tab_ && !active_tab_->IsNativePage())
+             ? active_tab_->web_contents()
+             : nullptr;
 }
 
 bool VrShell::ShouldDisplayURL() const {

chrome/browser/android/vr_shell/vr_shell.h

diff --git a/chrome/browser/android/vr_shell/vr_shell.h b/chrome/browser/android/vr_shell/vr_shell.h
index a44c85b..417a14a 100644
--- a/chrome/browser/android/vr_shell/vr_shell.h
+++ b/chrome/browser/android/vr_shell/vr_shell.h
@@ -13,6 +13,7 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
+#include "chrome/browser/android/tab_android.h"
 #include "chrome/browser/ui/toolbar/chrome_toolbar_model_delegate.h"
 #include "chrome/browser/vr/exit_vr_prompt_choice.h"
 #include "chrome/browser/vr/ui_interface.h"
@@ -82,7 +83,7 @@
   void SwapContents(
       JNIEnv* env,
       const base::android::JavaParamRef<jobject>& obj,
-      const base::android::JavaParamRef<jobject>& web_contents,
+      const base::android::JavaParamRef<jobject>& tab,
       const base::android::JavaParamRef<jobject>& android_ui_gesture_target);
   void Destroy(JNIEnv* env, const base::android::JavaParamRef<jobject>& obj);
   void OnTriggerEvent(JNIEnv* env,
@@ -226,7 +227,7 @@
 
   bool webvr_mode_ = false;
 
-  content::WebContents* web_contents_ = nullptr;
+  TabAndroid* active_tab_ = nullptr;
   base::android::ScopedJavaGlobalRef<jobject> j_motion_event_synthesizer_;
   ui::WindowAndroid* window_;
   std::unique_ptr<VrCompositor> compositor_;

chrome/browser/android/vr_shell/vr_shell_delegate.cc

diff --git a/chrome/browser/android/vr_shell/vr_shell_delegate.cc b/chrome/browser/android/vr_shell/vr_shell_delegate.cc
index b247e2e1..7a76d7c6 100644
--- a/chrome/browser/android/vr_shell/vr_shell_delegate.cc
+++ b/chrome/browser/android/vr_shell/vr_shell_delegate.cc
@@ -14,6 +14,7 @@
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents_observer.h"
+#include "content/public/common/origin_util.h"
 #include "device/vr/android/gvr/gvr_delegate.h"
 #include "device/vr/android/gvr/gvr_device.h"
 #include "device/vr/android/gvr/gvr_device_provider.h"
@@ -30,11 +31,21 @@
 
 namespace {
 
-content::RenderFrameHost* getHostForDisplay(device::VRDisplayImpl* display) {
+content::RenderFrameHost* GetHostForDisplay(device::VRDisplayImpl* display) {
   return content::RenderFrameHost::FromID(display->ProcessId(),
                                           display->RoutingId());
 }
 
+bool IsSecureContext(content::RenderFrameHost* host) {
+  DCHECK(host);
+  while (host != nullptr) {
+    if (!content::IsOriginSecure(host->GetLastCommittedURL()))
+      return false;
+    host = host->GetParent();
+  }
+  return true;
+}
+
 }  // namespace
 
 class DelegateWebContentsObserver : public content::WebContentsObserver {
@@ -135,6 +146,15 @@
 
   base::ResetAndReturn(&present_callback_).Run(success);
   pending_successful_present_request_ = false;
+  if (!success)
+    return;
+  device::VRDisplayImpl* presenting_display =
+      device_provider_->Device()->GetPresentingDisplay();
+  CHECK(presenting_display);
+  content::RenderFrameHost* host = GetHostForDisplay(presenting_display);
+  if (!host)
+    return;
+  gvr_delegate_->SetWebVRSecureOrigin(IsSecureContext(host));
 }
 
 void VrShellDelegate::DisplayActivate(JNIEnv* env,
@@ -254,7 +274,7 @@
 }
 
 void VrShellDelegate::OnDisplayAdded(device::VRDisplayImpl* display) {
-  content::RenderFrameHost* host = getHostForDisplay(display);
+  content::RenderFrameHost* host = GetHostForDisplay(display);
   if (host == nullptr)
     return;
   content::WebContents* web_contents =
@@ -288,7 +308,7 @@
 
 void VrShellDelegate::OnListeningForActivateChanged(
     device::VRDisplayImpl* display) {
-  content::RenderFrameHost* host = getHostForDisplay(display);
+  content::RenderFrameHost* host = GetHostForDisplay(display);
   bool has_focus = host != nullptr && host->GetView()->HasFocus();
   if (display->ListeningForActivate() && has_focus) {
     OnFocusedAndActivatable(display);
@@ -346,7 +366,7 @@
 void VrShellDelegate::GetNextMagicWindowPose(
     device::VRDisplayImpl* display,
     device::mojom::VRDisplay::GetNextMagicWindowPoseCallback callback) {
-  content::RenderFrameHost* host = getHostForDisplay(display);
+  content::RenderFrameHost* host = GetHostForDisplay(display);
   if (!gvr_api_ || gvr_delegate_ || host == nullptr ||
       !host->GetView()->HasFocus()) {
     std::move(callback).Run(nullptr);

chrome/browser/apps/guest_view/web_view_browsertest.cc

diff --git a/chrome/browser/apps/guest_view/web_view_browsertest.cc b/chrome/browser/apps/guest_view/web_view_browsertest.cc
index 646ad7b..3358114 100644
--- a/chrome/browser/apps/guest_view/web_view_browsertest.cc
+++ b/chrome/browser/apps/guest_view/web_view_browsertest.cc
@@ -3571,14 +3571,13 @@
     }
   }
 
-  void AccessibilityEventsReceived(
-      ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
-      const ui::AXTreeUpdate& update,
-      const std::vector<content::AXEventNotificationDetails>& events) override {
-    for (auto& event : events) {
-      if (event.event_type == event_ && update.nodes.size() > 0) {
+  void AccessibilityEventReceived(
+      const std::vector<content::AXEventNotificationDetails>& details_vector)
+          override {
+    for (auto& details : details_vector) {
+      if (details.event_type == event_ && details.update.nodes.size() > 0) {
         count_++;
-        node_data_ = update.nodes[0];
+        node_data_ = details.update.nodes[0];
         loop_runner_->Quit();
       }
     }

chrome/browser/chromeos/BUILD.gn

diff --git a/chrome/browser/chromeos/BUILD.gn b/chrome/browser/chromeos/BUILD.gn
index c021113e..d42e4550 100644
--- a/chrome/browser/chromeos/BUILD.gn
+++ b/chrome/browser/chromeos/BUILD.gn
@@ -1337,6 +1337,8 @@
     "printing/cups_print_job_notification.h",
     "printing/cups_print_job_notification_manager.cc",
     "printing/cups_print_job_notification_manager.h",
+    "printing/cups_printers_manager.cc",
+    "printing/cups_printers_manager.h",
     "printing/ppd_provider_factory.cc",
     "printing/ppd_provider_factory.h",
     "printing/printer_configurer.cc",
@@ -1874,6 +1876,7 @@
     "power/renderer_freezer_unittest.cc",
     "preferences_unittest.cc",
     "printing/combining_printer_detector_unittest.cc",
+    "printing/cups_printers_manager_unittest.cc",
     "printing/printer_event_tracker_unittest.cc",
     "printing/specifics_translation_unittest.cc",
     "printing/synced_printers_manager_unittest.cc",

chrome/browser/chromeos/arc/accessibility/ax_tree_source_arc.cc

diff --git a/chrome/browser/chromeos/arc/accessibility/ax_tree_source_arc.cc b/chrome/browser/chromeos/arc/accessibility/ax_tree_source_arc.cc
index ab79235..8c974e9 100644
--- a/chrome/browser/chromeos/arc/accessibility/ax_tree_source_arc.cc
+++ b/chrome/browser/chromeos/arc/accessibility/ax_tree_source_arc.cc
@@ -299,19 +299,18 @@
     }
   }
 
-  std::vector<ExtensionMsg_AccessibilityEventParams> events;
-  ExtensionMsg_AccessibilityEventParams event;
-  event.event_type = ToAXEvent(event_data->event_type);
-  event.id = event_data->source_id;
-  events.push_back(event);
+  ExtensionMsg_AccessibilityEventParams params;
+  params.event_type = ToAXEvent(event_data->event_type);
 
-  ui::AXTreeUpdate update;
+  params.tree_id = tree_id();
+  params.id = event_data->source_id;
+
   current_tree_serializer_->SerializeChanges(GetFromId(event_data->source_id),
-                                             &update);
+                                             &params.update);
 
   extensions::AutomationEventRouter* router =
       extensions::AutomationEventRouter::GetInstance();
-  router->DispatchAccessibilityEvents(tree_id(), update, events);
+  router->DispatchAccessibilityEvent(params);
 }
 
 void AXTreeSourceArc::Focus(aura::Window* window) {

chrome/browser/chromeos/arc/voice_interaction/arc_voice_interaction_framework_service.cc

diff --git a/chrome/browser/chromeos/arc/voice_interaction/arc_voice_interaction_framework_service.cc b/chrome/browser/chromeos/arc/voice_interaction/arc_voice_interaction_framework_service.cc
index 522ec8da..a2a2c17 100644
--- a/chrome/browser/chromeos/arc/voice_interaction/arc_voice_interaction_framework_service.cc
+++ b/chrome/browser/chromeos/arc/voice_interaction/arc_voice_interaction_framework_service.cc
@@ -397,8 +397,10 @@
     const gfx::Rect& rect) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
+  VLOG(1) << "Start voice interaction.";
   if (!Profile::FromBrowserContext(context_)->GetPrefs()->GetBoolean(
           prefs::kArcVoiceInteractionValuePropAccepted)) {
+    VLOG(1) << "Voice interaction feature not accepted.";
     // If voice interaction value prop already showing, return.
     if (chromeos::LoginDisplayHost::default_host())
       return;
@@ -413,6 +415,7 @@
   }
 
   if (!arc_bridge_service_->voice_interaction_framework()->has_instance()) {
+    VLOG(1) << "Instance not ready.";
     SetArcCpuRestriction(false);
     is_request_pending_ = true;
     return;
@@ -436,6 +439,7 @@
     DCHECK(framework_instance);
     framework_instance->StartVoiceInteractionSessionForRegion(rect);
   }
+  VLOG(1) << "Sent voice interaction request.";
 }
 
 bool ArcVoiceInteractionFrameworkService::ValidateTimeSinceUserInteraction() {
@@ -475,6 +479,7 @@
       context_request_remaining_count_) {
     // If next request starts too soon and there is an active session in action,
     // we should drop it.
+    VLOG(1) << "Rejected voice interaction request.";
     return false;
   }
   user_interaction_start_time_ = start_time;

chrome/browser/chromeos/policy/device_policy_decoder_chromeos.cc

diff --git a/chrome/browser/chromeos/policy/device_policy_decoder_chromeos.cc b/chrome/browser/chromeos/policy/device_policy_decoder_chromeos.cc
index 033f492..8810dd42 100644
--- a/chrome/browser/chromeos/policy/device_policy_decoder_chromeos.cc
+++ b/chrome/browser/chromeos/policy/device_policy_decoder_chromeos.cc
@@ -13,6 +13,7 @@
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
@@ -110,6 +111,30 @@
   return base::MakeUnique<base::Value>(kConnectionTypes[value]);
 }
 
+// Parse Timestamp to Dictionary
+std::unique_ptr<base::DictionaryValue> ParseWeeklyTime(
+    const em::WeeklyTimeProto& weekly_time) {
+  auto weekly_time_res = base::MakeUnique<base::DictionaryValue>();
+  if (!weekly_time.has_weekday()) {
+    LOG(ERROR) << "Day of week in interval can't be absent.";
+    return nullptr;
+  }
+  if (!weekly_time.has_time()) {
+    LOG(ERROR) << "Time in interval can't be absent.";
+    return nullptr;
+  }
+  weekly_time_res->SetInteger("weekday", weekly_time.weekday());
+  int time_of_day = weekly_time.time();
+  const int kMillisecondsInDay = base::TimeDelta::FromDays(1).InMilliseconds();
+  if (!(time_of_day >= 0 && time_of_day < kMillisecondsInDay)) {
+    LOG(ERROR) << "Invalid time value: " << time_of_day
+               << ", the value should be in [0; " << kMillisecondsInDay << ").";
+    return nullptr;
+  }
+  weekly_time_res->SetInteger("time", time_of_day);
+  return weekly_time_res;
+}
+
 void DecodeLoginPolicies(const em::ChromeDeviceSettingsProto& policy,
                          PolicyMap* policies) {
   if (policy.has_guest_mode_enabled()) {
@@ -887,8 +912,43 @@
                   POLICY_SOURCE_CLOUD, DecodeIntegerValue(container.mode()),
                   nullptr);
   }
-}
 
+  if (policy.has_device_off_hours()) {
+    const em::DeviceOffHoursProto& container(policy.device_off_hours());
+    auto off_hours = base::MakeUnique<base::DictionaryValue>();
+    auto intervals = base::MakeUnique<base::ListValue>();
+    for (const auto& entry : container.interval()) {
+      auto interval = base::MakeUnique<base::DictionaryValue>();
+      if (entry.has_start()) {
+        auto start = ParseWeeklyTime(entry.start());
+        if (!start) {
+          continue;
+        }
+        interval->SetDictionary("start", std::move(start));
+      }
+      if (entry.has_end()) {
+        auto end = ParseWeeklyTime(entry.end());
+        if (!end) {
+          continue;
+        }
+        interval->SetDictionary("end", std::move(end));
+      }
+      intervals->Append(std::move(interval));
+    }
+    off_hours->SetList("intervals", std::move(intervals));
+    auto policy = base::MakeUnique<base::ListValue>();
+    for (const auto& entry : container.ignored_policy()) {
+      policy->AppendString(entry);
+    }
+    off_hours->SetList("ignored_policies", std::move(policy));
+    if (container.has_timezone()) {
+      off_hours->SetString("timezone", container.timezone());
+    }
+    policies->Set(key::kDeviceOffHours, POLICY_LEVEL_MANDATORY,
+                  POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+                  std::move(off_hours), nullptr);
+  }
+}
 }  // namespace
 
 void DecodeDevicePolicy(const em::ChromeDeviceSettingsProto& policy,

chrome/browser/chromeos/policy/proto/chrome_device_policy.proto

diff --git a/chrome/browser/chromeos/policy/proto/chrome_device_policy.proto b/chrome/browser/chromeos/policy/proto/chrome_device_policy.proto
index 299accbb..9dccd79 100644
--- a/chrome/browser/chromeos/policy/proto/chrome_device_policy.proto
+++ b/chrome/browser/chromeos/policy/proto/chrome_device_policy.proto
@@ -820,6 +820,45 @@
   optional string name = 1;
 }
 
+// Day of the week and time settings for DeviceOffHoursIntervalProto.
+message WeeklyTimeProto {
+  enum Weekday {
+    MONDAY = 1;
+    TUESDAY = 2;
+    WEDNESDAY = 3;
+    THURSDAY = 4;
+    FRIDAY = 5;
+    SATURDAY = 6;
+    SUNDAY = 7;
+  }
+  // Day of week.
+  optional Weekday weekday = 1;
+  // Time of day in milliseconds from beginning of the day
+  // in timezone that is defined in DeviceOffHoursProto.
+  optional int32 time = 2;
+}
+
+// Start and end interval settings for DeviceOffHoursProto.
+message DeviceOffHoursIntervalProto {
+  optional WeeklyTimeProto start = 1;
+  optional WeeklyTimeProto end = 2;
+}
+
+// Allow less restricted using of Chromebooks that are managed by school,
+// while the device is not at school ("OffHours").
+message DeviceOffHoursProto {
+  // List of intervals when ignored policies are not applied.
+  repeated DeviceOffHoursIntervalProto interval = 1;
+  // Timezone in the same format as SystemTimezoneProto.timezone.
+  // If timezone isn't set then "GMT" will be used
+  optional string timezone = 2;
+  // List of policies which settings are ignored during OffHours mode.
+  // List contains policy names from ChromeDeviceSettingsProto
+  // (i.e. "device_policy_refresh_rate")
+  // During OffHoursMode default settings of ignored policies are used.
+  repeated string ignored_policy = 3;
+}
+
 message ChromeDeviceSettingsProto {
   optional DevicePolicyRefreshRateProto device_policy_refresh_rate = 1;
   optional UserWhitelistProto user_whitelist = 2;
@@ -883,4 +922,5 @@
   optional DeviceSecondFactorAuthenticationProto
       device_second_factor_authentication = 52;
   optional CastReceiverNameProto cast_receiver_name = 53;
+  optional DeviceOffHoursProto device_off_hours = 54;
 }

chrome/browser/chromeos/printing/cups_printers_manager.cc

diff --git a/chrome/browser/chromeos/printing/cups_printers_manager.cc b/chrome/browser/chromeos/printing/cups_printers_manager.cc
new file mode 100644
index 0000000..e8aac05
--- /dev/null
+++ b/chrome/browser/chromeos/printing/cups_printers_manager.cc
@@ -0,0 +1,375 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/chromeos/printing/cups_printers_manager.h"
+
+#include <algorithm>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "base/memory/singleton.h"
+#include "base/observer_list.h"
+#include "base/scoped_observer.h"
+#include "chrome/browser/chromeos/printing/ppd_provider_factory.h"
+#include "chrome/browser/chromeos/printing/synced_printers_manager.h"
+#include "chrome/browser/chromeos/printing/synced_printers_manager_factory.h"
+#include "chrome/browser/chromeos/printing/usb_printer_detector.h"
+#include "chrome/browser/chromeos/printing/usb_printer_detector_factory.h"
+#include "chrome/browser/profiles/profile.h"
+
+namespace chromeos {
+namespace {
+
+class CupsPrintersManagerImpl;
+
+// Since CupsPrintersManager listens to multiple PrinterDetectors, we need to
+// disambiguate incoming observer calls based on their source, and so can't
+// implement PrinterDetector::Observer directly in CupsPrintersManagerImpl.
+class PrinterDetectorObserverProxy : public PrinterDetector::Observer {
+ public:
+  PrinterDetectorObserverProxy(CupsPrintersManagerImpl* parent,
+                               int id,
+                               PrinterDetector* detector)
+      : parent_(parent), id_(id), observer_(this) {
+    observer_.Add(detector);
+  }
+  ~PrinterDetectorObserverProxy() override = default;
+
+  // Defined out of line because we need the CupsPrintersManagerImpl
+  // definition first.
+  void OnPrintersFound(
+      const std::vector<PrinterDetector::DetectedPrinter>& printers) override;
+
+  // We don't do anything with OnPrinterScanComplete() at the moment, so just
+  // stub it out.
+  void OnPrinterScanComplete() override {}
+
+ private:
+  CupsPrintersManagerImpl* parent_;
+  int id_;
+  ScopedObserver<PrinterDetector, PrinterDetector::Observer> observer_;
+};
+
+// Return the set of ids for the given list of printers.
+std::unordered_set<std::string> GetIdsSet(
+    const std::vector<Printer>& printers) {
+  std::unordered_set<std::string> ret;
+  for (const Printer& printer : printers) {
+    ret.insert(printer.id());
+  }
+  return ret;
+}
+
+// This is akin to python's filter() builtin, but with reverse polarity on the
+// test function -- *remove* all entries in printers for which test_fn returns
+// true, discard the rest.
+void FilterOutPrinters(std::vector<Printer>* printers,
+                       std::function<bool(const Printer&)> test_fn) {
+  auto new_end = std::remove_if(printers->begin(), printers->end(), test_fn);
+  printers->resize(new_end - printers->begin());
+}
+
+class CupsPrintersManagerImpl : public CupsPrintersManager,
+                                public SyncedPrintersManager::Observer {
+ public:
+  // Identifiers for each of the underlying PrinterDetectors this
+  // class observes.
+  enum DetectorIds {
+    kUsbDetector,
+    kZeroconfDetector,
+  };
+
+  CupsPrintersManagerImpl(SyncedPrintersManager* synced_printers_manager,
+                          PrinterDetector* usb_detector,
+                          PrinterDetector* zeroconf_detector,
+                          scoped_refptr<PpdProvider> ppd_provider)
+      : synced_printers_manager_(synced_printers_manager),
+        synced_printers_manager_observer_(this),
+        usb_detector_(usb_detector),
+        usb_detector_observer_proxy_(this, kUsbDetector, usb_detector_),
+        zeroconf_detector_(zeroconf_detector),
+        zeroconf_detector_observer_proxy_(this,
+                                          kZeroconfDetector,
+                                          zeroconf_detector_),
+        ppd_provider_(std::move(ppd_provider)),
+        printers_(kNumPrinterClasses),
+        weak_ptr_factory_(this) {
+    synced_printers_manager_observer_.Add(synced_printers_manager_);
+  }
+
+  ~CupsPrintersManagerImpl() override = default;
+
+  // Public API function.
+  std::vector<Printer> GetPrinters(PrinterClass printer_class) const override {
+    return printers_.at(printer_class);
+  }
+
+  // Public API function.
+  void RemoveUnavailablePrinters(
+      std::vector<Printer>* printers) const override {
+    FilterOutPrinters(printers, [this](const Printer& printer) {
+      return !PrinterAvailable(printer);
+    });
+  }
+
+  // Public API function.
+  void UpdateConfiguredPrinter(const Printer& printer) override {
+    synced_printers_manager_->UpdateConfiguredPrinter(printer);
+  }
+
+  // Public API function.
+  void RemoveConfiguredPrinter(const std::string& printer_id) override {
+    synced_printers_manager_->RemoveConfiguredPrinter(printer_id);
+  }
+
+  // Public API function.
+  void AddObserver(CupsPrintersManager::Observer* observer) override {
+    observer_list_.AddObserver(observer);
+  }
+
+  // Public API function.
+  void RemoveObserver(CupsPrintersManager::Observer* observer) override {
+    observer_list_.RemoveObserver(observer);
+  }
+
+  // Public API function.
+  void PrinterInstalled(const Printer& printer) override {
+    synced_printers_manager_->PrinterInstalled(printer);
+  }
+
+  // Public API function.
+  bool IsPrinterInstalled(const Printer& printer) const override {
+    return synced_printers_manager_->IsConfigurationCurrent(printer);
+  }
+
+  // Public API function.
+  // Note this is linear in the number of printers.  If the number of printers
+  // gets so large that a linear search is prohibative, we'll have to rethink
+  // more than just this function.
+  std::unique_ptr<Printer> GetPrinter(const std::string& id) const override {
+    for (const auto& printer_list : printers_) {
+      for (const auto& printer : printer_list) {
+        if (printer.id() == id) {
+          return base::MakeUnique<Printer>(printer);
+        }
+      }
+    }
+    return std::unique_ptr<Printer>();
+  }
+
+  // SyncedPrintersManager::Observer implementation
+  void OnConfiguredPrintersChanged(
+      const std::vector<Printer>& printers) override {
+    printers_[kConfigured] = printers;
+    configured_printer_ids_ = GetIdsSet(printers);
+    for (auto& observer : observer_list_) {
+      observer.OnPrintersChanged(kConfigured, printers_[kConfigured]);
+    }
+    RebuildDetectedLists();
+  }
+
+  // SyncedPrintersManager::Observer implementation
+  void OnEnterprisePrintersChanged(
+      const std::vector<Printer>& printers) override {
+    printers_[kEnterprise] = printers;
+    for (auto& observer : observer_list_) {
+      observer.OnPrintersChanged(kEnterprise, printers_[kEnterprise]);
+    }
+  }
+
+  // Callback entry point for PrinterDetectorObserverProxys owned by this
+  // object.
+  void OnPrintersFound(
+      int detector_id,
+      const std::vector<PrinterDetector::DetectedPrinter>& printers) {
+    switch (detector_id) {
+      case kUsbDetector:
+        usb_detections_ = printers;
+        break;
+      case kZeroconfDetector:
+        zeroconf_detections_ = printers;
+        break;
+    }
+    RebuildDetectedLists();
+  }
+
+ private:
+  // Return whether or not we believe this printer is currently available for
+  // printing.  This is not a perfect test -- we just assume any IPP printers
+  // are available because, in cases where there are a large number of
+  // printers available, probing IPP printers would generate too much network
+  // spam.  This is intended to help filter out local printers that are not
+  // available (USB, zeroconf, ...)
+  //
+  // TODO(justincarlson) - Implement this.  Until it's implemented, we'll never
+  // filter out unavailable printers from potential printer targets.  While
+  // suboptimal, this is ok--it just means that we will fail to print if the
+  // user selects a printer that's not available.
+  bool PrinterAvailable(const Printer& printer) const { return true; }
+
+  void AddDetectedList(
+      const std::vector<PrinterDetector::DetectedPrinter>& detected_list) {
+    for (const PrinterDetector::DetectedPrinter& detected : detected_list) {
+      if (base::ContainsKey(configured_printer_ids_, detected.printer.id())) {
+        // It's already in the configured classes, so neither automatic nor
+        // discovered is appropriate.  Skip it.
+        continue;
+      }
+      auto it = detected_printer_ppd_references_.find(detected.printer.id());
+      if (it != detected_printer_ppd_references_.end()) {
+        if (it->second == nullptr) {
+          // We couldn't figure out this printer, so it's in the discovered
+          // class.
+          printers_[kDiscovered].push_back(detected.printer);
+        } else {
+          // We have a ppd reference, so we think we can set this up
+          // automatically.
+          printers_[kAutomatic].push_back(detected.printer);
+          *printers_[kAutomatic].back().mutable_ppd_reference() = *it->second;
+        }
+      } else {
+        // Didn't find an entry for this printer in the PpdReferences cache.
+        // We need to ask PpdProvider whether or not it can determine a
+        // PpdReference.  If there's not already an outstanding request for
+        // one, start one.  When the request comes back, we'll rerun
+        // classification and then should be able to figure out where this
+        // printer belongs.
+        if (!base::ContainsKey(inflight_ppd_reference_resolutions_,
+                               detected.printer.id())) {
+          inflight_ppd_reference_resolutions_.insert(detected.printer.id());
+          ppd_provider_->ResolvePpdReference(
+              detected.ppd_search_data,
+              base::Bind(&CupsPrintersManagerImpl::ResolvePpdReferenceDone,
+                         weak_ptr_factory_.GetWeakPtr(),
+                         detected.printer.id()));
+        }
+      }
+    }
+  }
+
+  // Rebuild the Automatic and Discovered printers lists.
+  void RebuildDetectedLists() {
+    printers_[kAutomatic].clear();
+    printers_[kDiscovered].clear();
+    AddDetectedList(usb_detections_);
+    AddDetectedList(zeroconf_detections_);
+
+    for (auto& observer : observer_list_) {
+      observer.OnPrintersChanged(kAutomatic, printers_[kAutomatic]);
+      observer.OnPrintersChanged(kDiscovered, printers_[kDiscovered]);
+    }
+  }
+
+  // Callback invoked on completion of PpdProvider::ResolvePpdReference.
+  void ResolvePpdReferenceDone(const std::string& printer_id,
+                               PpdProvider::CallbackResultCode code,
+                               const Printer::PpdReference& ref) {
+    inflight_ppd_reference_resolutions_.erase(printer_id);
+    // Create the entry.
+    std::unique_ptr<Printer::PpdReference>& value =
+        detected_printer_ppd_references_[printer_id];
+    if (code == PpdProvider::SUCCESS) {
+      // If we got something, populate the entry.  Otherwise let it
+      // just remain null.
+      value.reset(new Printer::PpdReference(ref));
+    }
+    RebuildDetectedLists();
+  }
+
+  // Source lists for detected printers.
+  std::vector<PrinterDetector::DetectedPrinter> usb_detections_;
+  std::vector<PrinterDetector::DetectedPrinter> zeroconf_detections_;
+
+  // Not owned.
+  SyncedPrintersManager* synced_printers_manager_;
+  ScopedObserver<SyncedPrintersManager, SyncedPrintersManager::Observer>
+      synced_printers_manager_observer_;
+
+  // Not owned.
+  PrinterDetector* usb_detector_;
+  PrinterDetectorObserverProxy usb_detector_observer_proxy_;
+
+  // Not owned.
+  PrinterDetector* zeroconf_detector_;
+  PrinterDetectorObserverProxy zeroconf_detector_observer_proxy_;
+
+  scoped_refptr<PpdProvider> ppd_provider_;
+
+  // Categorized printers.  This is indexed by PrinterClass.
+  std::vector<std::vector<Printer>> printers_;
+
+  // Printer ids that occur in one of our categories or printers.
+  std::unordered_set<std::string> known_printer_ids_;
+
+  // This is a dual-purpose structure.  The keys in the map are printer ids.
+  // If an entry exists in this map it means we have received a response from
+  // PpdProvider about a PpdReference for the given printer.  A null value
+  // means we don't have a PpdReference (and so can't set up this printer
+  // automatically).
+  std::unordered_map<std::string, std::unique_ptr<Printer::PpdReference>>
+      detected_printer_ppd_references_;
+
+  // Printer ids for which we have sent off a request to PpdProvider for a ppd
+  // reference, but have not yet gotten a response.
+  std::unordered_set<std::string> inflight_ppd_reference_resolutions_;
+
+  // Ids of all printers in the configured class.
+  std::unordered_set<std::string> configured_printer_ids_;
+
+  base::ObserverList<CupsPrintersManager::Observer> observer_list_;
+  base::WeakPtrFactory<CupsPrintersManagerImpl> weak_ptr_factory_;
+};
+
+void PrinterDetectorObserverProxy::OnPrintersFound(
+    const std::vector<PrinterDetector::DetectedPrinter>& printers) {
+  parent_->OnPrintersFound(id_, printers);
+}
+
+// Placeholder stubbed out detector implementation for Zeroconf detection (the
+// actual implementation hasn't landed yet).  This stub has no state and
+// never detects anything.
+class ZeroconfDetectorStub : public PrinterDetector {
+ public:
+  ~ZeroconfDetectorStub() override {}
+  void Start() override {}
+  void AddObserver(Observer* observer) override {}
+  void RemoveObserver(Observer* observer) override {}
+  std::vector<DetectedPrinter> GetPrinters() override {
+    return std::vector<DetectedPrinter>();
+  }
+
+  // Since ZeroconfDetector will not be owned by CupsPrintersManager, the
+  // easiest thing to do for now is to make the stub a singleton.
+  static ZeroconfDetectorStub* GetInstance() {
+    return base::Singleton<ZeroconfDetectorStub>::get();
+  }
+};
+
+}  // namespace
+
+// static
+std::unique_ptr<CupsPrintersManager> CupsPrintersManager::Create(
+    Profile* profile) {
+  return base::MakeUnique<CupsPrintersManagerImpl>(
+      SyncedPrintersManagerFactory::GetInstance()->GetForBrowserContext(
+          profile),
+      UsbPrinterDetectorFactory::GetInstance()->Get(profile),
+      ZeroconfDetectorStub::GetInstance(), CreatePpdProvider(profile));
+}
+
+// static
+std::unique_ptr<CupsPrintersManager> CupsPrintersManager::Create(
+    SyncedPrintersManager* synced_printers_manager,
+    PrinterDetector* usb_detector,
+    PrinterDetector* zeroconf_detector,
+    scoped_refptr<PpdProvider> ppd_provider) {
+  return base::MakeUnique<CupsPrintersManagerImpl>(
+      synced_printers_manager, usb_detector, zeroconf_detector,
+      std::move(ppd_provider));
+}
+
+}  // namespace chromeos

chrome/browser/chromeos/printing/cups_printers_manager.h

diff --git a/chrome/browser/chromeos/printing/cups_printers_manager.h b/chrome/browser/chromeos/printing/cups_printers_manager.h
new file mode 100644
index 0000000..aca5be2
--- /dev/null
+++ b/chrome/browser/chromeos/printing/cups_printers_manager.h
@@ -0,0 +1,94 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+#ifndef CHROME_BROWSER_CHROMEOS_PRINTING_CUPS_PRINTERS_MANAGER_H_
+#define CHROME_BROWSER_CHROMEOS_PRINTING_CUPS_PRINTERS_MANAGER_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/memory/ref_counted.h"
+#include "chromeos/printing/printer_configuration.h"
+
+class Profile;
+
+namespace chromeos {
+
+class PpdProvider;
+class PrinterDetector;
+class SyncedPrintersManager;
+
+class CupsPrintersManager {
+ public:
+  // Classes of printers tracked.  See doc/cups_printers_management.md for
+  // details on what these mean.
+  enum PrinterClass {
+    kConfigured,
+    kEnterprise,
+    kAutomatic,
+    kDiscovered,
+    kNumPrinterClasses
+  };
+
+  class Observer {
+   public:
+    virtual ~Observer() = default;
+    // The list of printers in this class has changed to the given printers.
+    virtual void OnPrintersChanged(PrinterClass printer_class,
+                                   const std::vector<Printer>& printers) = 0;
+  };
+
+  // Factory function.
+  static std::unique_ptr<CupsPrintersManager> Create(Profile* profile);
+
+  // Factory function that allows injected dependencies, for testing.  Ownership
+  // is not taken of any of the raw-pointer arguments.
+  static std::unique_ptr<CupsPrintersManager> Create(
+      SyncedPrintersManager* synced_printers_manager,
+      PrinterDetector* usb_printer_detector,
+      PrinterDetector* zeroconf_printer_detector,
+      scoped_refptr<PpdProvider> ppd_provider);
+
+  virtual ~CupsPrintersManager() = default;
+
+  // Get the known printers in the given class.
+  virtual std::vector<Printer> GetPrinters(
+      PrinterClass printer_class) const = 0;
+
+  // Remove any printer from printers that we know we cannot currently
+  // talk to.  Examples would be USB printers that are not currently
+  // plugged in, or Zeroconf printers that have not been detected this
+  // session.
+  virtual void RemoveUnavailablePrinters(
+      std::vector<Printer>* printers) const = 0;
+
+  // Update or save a printer as a configured printer.  If this is the same as
+  // an existing configured printer, the entry will be updated.  If the printer
+  // appears in a class other than configured, it will be moved to the
+  // configured class.
+  virtual void UpdateConfiguredPrinter(const Printer& printer) = 0;
+
+  // Remove the configured printer with the given id.  This is a NOP if
+  // the printer_id is not that of a configured printer.
+  virtual void RemoveConfiguredPrinter(const std::string& printer_id) = 0;
+
+  // Add or remove observers.
+  virtual void AddObserver(Observer* observer) = 0;
+  virtual void RemoveObserver(Observer* observer) = 0;
+
+  // Record that the given printers has been installed in CUPS for usage.
+  virtual void PrinterInstalled(const Printer& printer) = 0;
+
+  // Returns true if |printer| is currently installed in CUPS with this
+  // configuration.
+  virtual bool IsPrinterInstalled(const Printer& printer) const = 0;
+
+  // Look for a printer with the given id in any class.  Returns a copy of the
+  // printer if found, null if not found.
+  virtual std::unique_ptr<Printer> GetPrinter(const std::string& id) const = 0;
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_PRINTING_CUPS_PRINTERS_MANAGER_H_

chrome/browser/chromeos/printing/cups_printers_manager_unittest.cc

diff --git a/chrome/browser/chromeos/printing/cups_printers_manager_unittest.cc b/chrome/browser/chromeos/printing/cups_printers_manager_unittest.cc
new file mode 100644
index 0000000..c13c8d5c
--- /dev/null
+++ b/chrome/browser/chromeos/printing/cups_printers_manager_unittest.cc
@@ -0,0 +1,461 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+#include "chrome/browser/chromeos/printing/cups_printers_manager.h"
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/sequenced_task_runner.h"
+#include "base/test/scoped_task_environment.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "chrome/browser/chromeos/printing/synced_printers_manager.h"
+#include "chrome/browser/chromeos/printing/usb_printer_detector.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+namespace {
+
+// Fake backend for SyncedPrintersManager.  This allows us to poke arbitrary
+// changes in the configured and enterprise printer lists.
+class FakeSyncedPrintersManager : public SyncedPrintersManager {
+ public:
+  FakeSyncedPrintersManager() = default;
+  ~FakeSyncedPrintersManager() override = default;
+
+  // Returns the printers that are saved in preferences.
+  std::vector<Printer> GetConfiguredPrinters() const override {
+    return configured_printers_;
+  }
+
+  // Returns printers from enterprise policy.
+  std::vector<Printer> GetEnterprisePrinters() const override {
+    return enterprise_printers_;
+  }
+
+  // Attach |observer| for notification of events.  |observer| is expected to
+  // live on the same thread (UI) as this object.  OnPrinter* methods are
+  // invoked inline so calling RegisterPrinter in response to OnPrinterAdded is
+  // forbidden.
+  void AddObserver(SyncedPrintersManager::Observer* observer) override {
+    observers_.AddObserver(observer);
+  }
+
+  // Remove |observer| so that it no longer receives notifications.  After the
+  // completion of this method, the |observer| can be safely destroyed.
+  void RemoveObserver(SyncedPrintersManager::Observer* observer) override {
+    observers_.RemoveObserver(observer);
+  }
+
+  void UpdateConfiguredPrinter(const Printer& printer) override {
+    size_t i;
+    for (i = 0; i < configured_printers_.size(); ++i) {
+      if (configured_printers_[i].id() == printer.id()) {
+        configured_printers_[i] = printer;
+        break;
+      }
+    }
+    if (i == configured_printers_.size()) {
+      // Didn't find it, add it.
+      configured_printers_.push_back(printer);
+    }
+    for (Observer& observer : observers_) {
+      observer.OnConfiguredPrintersChanged(configured_printers_);
+    }
+  }
+
+  bool RemoveConfiguredPrinter(const std::string& printer_id) override {
+    for (auto it = configured_printers_.begin();
+         it != configured_printers_.end(); ++it) {
+      if (it->id() == printer_id) {
+        configured_printers_.erase(it);
+        for (Observer& observer : observers_) {
+          observer.OnConfiguredPrintersChanged(configured_printers_);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Everything else in the interface we either don't use in
+  // CupsPrintersManager, or just use in a simple pass-through manner that's not
+  // worth additional layers of testing on top of the testing in
+  // SyncedPrintersManager.
+  void PrinterInstalled(const Printer& printer) override {}
+  bool IsConfigurationCurrent(const Printer& printer) const override {
+    return true;
+  }
+  PrintersSyncBridge* GetSyncBridge() override { return nullptr; }
+  // Returns the printer with id |printer_id|, or nullptr if no such printer
+  // exists.  Searches both Configured and Enterprise printers.
+  std::unique_ptr<Printer> GetPrinter(
+      const std::string& printer_id) const override {
+    return nullptr;
+  }
+
+  // Fake manipulation functions.
+
+  // Add the given printers to the list of configured printers and
+  // notify observers.
+  void AddConfiguredPrinters(const std::vector<Printer>& printers) {
+    configured_printers_.insert(configured_printers_.end(), printers.begin(),
+                                printers.end());
+    for (Observer& observer : observers_) {
+      observer.OnConfiguredPrintersChanged(configured_printers_);
+    }
+  }
+
+  // Remove the printers with the given ids from the set of configured printers,
+  // notify observers.
+  void RemoveConfiguredPrinters(const std::unordered_set<std::string>& ids) {
+    RemovePrinters(ids, &configured_printers_);
+    for (Observer& observer : observers_) {
+      observer.OnConfiguredPrintersChanged(configured_printers_);
+    }
+  }
+
+  // Add the given printers to the list of enterprise printers and
+  // notify observers.
+  void AddEnterprisePrinters(const std::vector<Printer>& printers) {
+    enterprise_printers_.insert(enterprise_printers_.end(), printers.begin(),
+                                printers.end());
+    for (Observer& observer : observers_) {
+      observer.OnEnterprisePrintersChanged(enterprise_printers_);
+    }
+  }
+
+  // Remove the printers with the given ids from the set of enterprise printers,
+  // notify observers.
+  void RemoveEnterprisePrinters(const std::unordered_set<std::string>& ids) {
+    RemovePrinters(ids, &enterprise_printers_);
+    for (Observer& observer : observers_) {
+      observer.OnEnterprisePrintersChanged(enterprise_printers_);
+    }
+  }
+
+ private:
+  void RemovePrinters(const std::unordered_set<std::string>& ids,
+                      std::vector<Printer>* target) {
+    auto new_end = std::remove_if(target->begin(), target->end(),
+                                  [&ids](const Printer& printer) -> bool {
+                                    return base::ContainsKey(ids, printer.id());
+                                  });
+
+    target->resize(new_end - target->begin());
+  }
+
+  base::ObserverList<SyncedPrintersManager::Observer> observers_;
+  std::vector<Printer> configured_printers_;
+  std::vector<Printer> enterprise_printers_;
+};
+
+class FakePrinterDetector : public PrinterDetector {
+ public:
+  FakePrinterDetector() = default;
+  ~FakePrinterDetector() override = default;
+  void Start() override {}
+
+  void AddObserver(Observer* observer) override {
+    observers_.AddObserver(observer);
+  }
+  void RemoveObserver(Observer* observer) override {
+    observers_.RemoveObserver(observer);
+  }
+  std::vector<DetectedPrinter> GetPrinters() override { return detections_; }
+
+  void AddDetections(
+      const std::vector<PrinterDetector::DetectedPrinter>& new_detections) {
+    detections_.insert(detections_.end(), new_detections.begin(),
+                       new_detections.end());
+    for (Observer& observer : observers_) {
+      observer.OnPrintersFound(detections_);
+    }
+  }
+
+  // Remove printers that have ids in ids.
+  void RemoveDetections(const std::unordered_set<std::string>& ids) {
+    auto new_end =
+        std::remove_if(detections_.begin(), detections_.end(),
+                       [&ids](const DetectedPrinter& detection) -> bool {
+                         return base::ContainsKey(ids, detection.printer.id());
+                       });
+
+    detections_.resize(new_end - detections_.begin());
+  }
+
+ private:
+  std::vector<DetectedPrinter> detections_;
+  base::ObserverList<PrinterDetector::Observer> observers_;
+};
+
+// Fake PpdProvider backend.  This fake generates PpdReferences based on
+// the passed make_and_model strings using these rules:
+//
+// If make_and_model is empty, then we say NOT_FOUND
+// Otherwise, generate a ppd reference with make_and_model[0] as
+// the effective make and model in the PpdReference.
+class FakePpdProvider : public PpdProvider {
+ public:
+  FakePpdProvider() {}
+
+  void ResolvePpdReference(const PrinterSearchData& search_data,
+                           const ResolvePpdReferenceCallback& cb) override {
+    if (search_data.make_and_model.empty()) {
+      base::SequencedTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE,
+          base::Bind(cb, PpdProvider::NOT_FOUND, Printer::PpdReference()));
+    } else {
+      Printer::PpdReference ret;
+      ret.effective_make_and_model = search_data.make_and_model[0];
+      base::SequencedTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::Bind(cb, PpdProvider::SUCCESS, ret));
+    }
+  }
+
+  // These three functions are not used by CupsPrintersManager.
+  void ResolvePpd(const Printer::PpdReference& reference,
+                  const ResolvePpdCallback& cb) override {}
+  void ResolveManufacturers(const ResolveManufacturersCallback& cb) override {}
+  void ResolvePrinters(const std::string& manufacturer,
+                       const ResolvePrintersCallback& cb) override {}
+  void ReverseLookup(const std::string& effective_make_and_model,
+                     const ReverseLookupCallback& cb) override {}
+
+ private:
+  ~FakePpdProvider() override {}
+};
+
+// Expect that the printers in printers have the given ids, without
+// considering order.
+void ExpectPrinterIdsAre(const std::vector<Printer>& printers,
+                         const std::vector<std::string>& ids) {
+  std::vector<std::string> found_ids;
+  for (const Printer& printer : printers) {
+    found_ids.push_back(printer.id());
+  }
+  std::sort(found_ids.begin(), found_ids.end());
+  std::vector<std::string> sorted_ids(ids);
+  std::sort(sorted_ids.begin(), sorted_ids.end());
+  EXPECT_EQ(sorted_ids, found_ids);
+}
+
+class CupsPrintersManagerTest : public testing::Test,
+                                public CupsPrintersManager::Observer {
+ public:
+  CupsPrintersManagerTest()
+      : observed_printers_(CupsPrintersManager::kNumPrinterClasses),
+        ppd_provider_(new FakePpdProvider),
+        manager_(CupsPrintersManager::Create(&synced_printers_manager_,
+                                             &usb_detector_,
+                                             &zeroconf_detector_,
+                                             ppd_provider_)) {
+    manager_->AddObserver(this);
+  }
+
+  ~CupsPrintersManagerTest() override {}
+
+  // CupsPrintersManager::Observer implementation
+  void OnPrintersChanged(CupsPrintersManager::PrinterClass printer_class,
+                         const std::vector<Printer>& printers) override {
+    observed_printers_.at(printer_class) = printers;
+  }
+
+  // Check that, for the given printer class, the printers we have from the
+  // observation callback and the printers we have when we query the manager are
+  // both the same and have the passed ids.
+  void ExpectPrintersInClassAre(CupsPrintersManager::PrinterClass printer_class,
+                                const std::vector<std::string>& ids) {
+    ExpectPrinterIdsAre(manager_->GetPrinters(printer_class), ids);
+    ExpectPrinterIdsAre(observed_printers_.at(printer_class), ids);
+  }
+
+ protected:
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
+
+  // Captured printer lists from observer callbacks.
+  std::vector<std::vector<Printer>> observed_printers_;
+
+  // Backend fakes driving the CupsPrintersManager.
+  FakeSyncedPrintersManager synced_printers_manager_;
+  FakePrinterDetector usb_detector_;
+  FakePrinterDetector zeroconf_detector_;
+  scoped_refptr<FakePpdProvider> ppd_provider_;
+
+  // The manager being tested.  This must be declared after the fakes, as its
+  // initialization must come after that of the fakes.
+  std::unique_ptr<CupsPrintersManager> manager_;
+};
+
+// Pseudo-constructor for inline creation of a DetectedPrinter that should (in
+// this test) be handled as a Discovered printer (because it has no make and
+// model information, and that's now the FakePpdProvider is set up to determine
+// whether or not something has a Ppd available).
+PrinterDetector::DetectedPrinter MakeDiscoveredPrinter(const std::string& id) {
+  PrinterDetector::DetectedPrinter ret;
+  ret.printer.set_id(id);
+  return ret;
+}
+
+// Pseudo-constructor for inline creation of a DetectedPrinter that should (in
+// this test) be handled as an Automatic printer (because it has a make and
+// model string).
+PrinterDetector::DetectedPrinter MakeAutomaticPrinter(const std::string& id) {
+  PrinterDetector::DetectedPrinter ret;
+  ret.printer.set_id(id);
+  ret.ppd_search_data.make_and_model.push_back("make and model string");
+  return ret;
+}
+
+// Test that Enterprise printers from SyncedPrinterManager are
+// surfaced appropriately.
+TEST_F(CupsPrintersManagerTest, GetEnterprisePrinters) {
+  synced_printers_manager_.AddEnterprisePrinters(
+      {Printer("Foo"), Printer("Bar")});
+  scoped_task_environment_.RunUntilIdle();
+  ExpectPrintersInClassAre(CupsPrintersManager::kEnterprise, {"Foo", "Bar"});
+}
+
+// Test that Configured printers from SyncedPrinterManager are
+// surfaced appropriately.
+TEST_F(CupsPrintersManagerTest, GetConfiguredPrinters) {
+  synced_printers_manager_.AddConfiguredPrinters(
+      {Printer("Foo"), Printer("Bar")});
+  scoped_task_environment_.RunUntilIdle();
+  ExpectPrintersInClassAre(CupsPrintersManager::kConfigured, {"Foo", "Bar"});
+}
+
+// Test that USB printers from the usb detector are converted to 'Printer's and
+// surfaced appropriately.  One printer should be "automatic" because it has
+// a findable Ppd, the other should be "discovered".
+TEST_F(CupsPrintersManagerTest, GetUsbPrinters) {
+  usb_detector_.AddDetections({MakeDiscoveredPrinter("DiscoveredPrinter"),
+                               MakeAutomaticPrinter("AutomaticPrinter")});
+  scoped_task_environment_.RunUntilIdle();
+  ExpectPrintersInClassAre(CupsPrintersManager::kDiscovered,
+                           {"DiscoveredPrinter"});
+  ExpectPrintersInClassAre(CupsPrintersManager::kAutomatic,
+                           {"AutomaticPrinter"});
+}
+
+// Same as GetUsbPrinters, only for Zeroconf printers.
+TEST_F(CupsPrintersManagerTest, GetZeroconfPrinters) {
+  zeroconf_detector_.AddDetections({MakeDiscoveredPrinter("DiscoveredPrinter"),
+                                    MakeAutomaticPrinter("AutomaticPrinter")});
+  synced_printers_manager_.AddConfiguredPrinters(
+      {Printer("Foo"), Printer("Bar")});
+
+  scoped_task_environment_.RunUntilIdle();
+  ExpectPrintersInClassAre(CupsPrintersManager::kDiscovered,
+                           {"DiscoveredPrinter"});
+  ExpectPrintersInClassAre(CupsPrintersManager::kAutomatic,
+                           {"AutomaticPrinter"});
+}
+
+// Test that printers that appear in either a Configured or Enterprise set do
+// *not* appear in Discovered or Automatic, even if they are detected as such.
+TEST_F(CupsPrintersManagerTest, SyncedPrintersTrumpDetections) {
+  zeroconf_detector_.AddDetections({MakeDiscoveredPrinter("DiscoveredPrinter0"),
+                                    MakeDiscoveredPrinter("DiscoveredPrinter1"),
+                                    MakeAutomaticPrinter("AutomaticPrinter0"),
+                                    MakeAutomaticPrinter("AutomaticPrinter1")});
+  scoped_task_environment_.RunUntilIdle();
+  // Before we muck with anything else, check that automatic and discovered
+  // classes are what we intended to set up.
+  ExpectPrintersInClassAre(CupsPrintersManager::kDiscovered,
+                           {"DiscoveredPrinter0", "DiscoveredPrinter1"});
+  ExpectPrintersInClassAre(CupsPrintersManager::kAutomatic,
+                           {"AutomaticPrinter0", "AutomaticPrinter1"});
+
+  // Configure both the Discovered and Automatic printers.  This should put them
+  // into the Configured class and thus *remove* them from their previous
+  // classes.
+  manager_->UpdateConfiguredPrinter(Printer("DiscoveredPrinter0"));
+  manager_->UpdateConfiguredPrinter(Printer("AutomaticPrinter0"));
+  scoped_task_environment_.RunUntilIdle();
+  ExpectPrintersInClassAre(CupsPrintersManager::kDiscovered,
+                           {"DiscoveredPrinter1"});
+  ExpectPrintersInClassAre(CupsPrintersManager::kAutomatic,
+                           {"AutomaticPrinter1"});
+  ExpectPrintersInClassAre(CupsPrintersManager::kConfigured,
+                           {"DiscoveredPrinter0", "AutomaticPrinter0"});
+}
+
+// Test updates of configured printers.  Updates of existing configured printers
+// should propagate.  Updates of printers in other classes should result in
+// those printers becoming configured.  Updates of unknown printers should
+// result in a new configured printer.
+TEST_F(CupsPrintersManagerTest, UpdateConfiguredPrinter) {
+  // Start with a printer in each class named after the class it's in, except
+  // Enterprise which is not relevant to this test.
+  Printer existing_configured("Configured");
+  synced_printers_manager_.AddConfiguredPrinters({existing_configured});
+  usb_detector_.AddDetections({MakeDiscoveredPrinter("Discovered")});
+  zeroconf_detector_.AddDetections({MakeAutomaticPrinter("Automatic")});
+  scoped_task_environment_.RunUntilIdle();
+
+  // Sanity check that we do, indeed, have one printer in each class.
+  ExpectPrintersInClassAre(CupsPrintersManager::kConfigured, {"Configured"});
+  ExpectPrintersInClassAre(CupsPrintersManager::kAutomatic, {"Automatic"});
+  ExpectPrintersInClassAre(CupsPrintersManager::kDiscovered, {"Discovered"});
+
+  // Update the existing configured printer.  Check that the new display name
+  // propagated.
+  existing_configured.set_display_name("New Display Name");
+  manager_->UpdateConfiguredPrinter(existing_configured);
+  scoped_task_environment_.RunUntilIdle();
+  ExpectPrintersInClassAre(CupsPrintersManager::kConfigured, {"Configured"});
+  EXPECT_EQ(
+      manager_->GetPrinters(CupsPrintersManager::kConfigured)[0].display_name(),
+      "New Display Name");
+
+  // Do the same thing for the Automatic and Discovered printers.
+  // Create a configuration for the enterprise printer, which should shift it
+  // into the configured category.
+  manager_->UpdateConfiguredPrinter(Printer("Automatic"));
+  scoped_task_environment_.RunUntilIdle();
+  ExpectPrintersInClassAre(CupsPrintersManager::kAutomatic, {});
+  ExpectPrintersInClassAre(CupsPrintersManager::kConfigured,
+                           {"Automatic", "Configured"});
+
+  manager_->UpdateConfiguredPrinter(Printer("Discovered"));
+  scoped_task_environment_.RunUntilIdle();
+  ExpectPrintersInClassAre(CupsPrintersManager::kDiscovered, {});
+  ExpectPrintersInClassAre(CupsPrintersManager::kConfigured,
+                           {"Automatic", "Configured", "Discovered"});
+
+  // Update a printer we haven't seen before, which should just add it.
+  manager_->UpdateConfiguredPrinter(Printer("NewFangled"));
+  scoped_task_environment_.RunUntilIdle();
+  ExpectPrintersInClassAre(
+      CupsPrintersManager::kConfigured,
+      {"Automatic", "Configured", "Discovered", "NewFangled"});
+}
+
+// Test that GetPrinter() finds printers in any class, and returns null if
+// a printer is not found.
+TEST_F(CupsPrintersManagerTest, GetPrinter) {
+  synced_printers_manager_.AddConfiguredPrinters({Printer("Configured")});
+  synced_printers_manager_.AddEnterprisePrinters({Printer("Enterprise")});
+  usb_detector_.AddDetections({MakeDiscoveredPrinter("Discovered")});
+  zeroconf_detector_.AddDetections({MakeAutomaticPrinter("Automatic")});
+  scoped_task_environment_.RunUntilIdle();
+
+  for (const std::string& id :
+       {"Configured", "Enterprise", "Discovered", "Automatic"}) {
+    std::unique_ptr<Printer> printer = manager_->GetPrinter(id);
+    ASSERT_NE(printer, nullptr);
+    EXPECT_EQ(printer->id(), id);
+  }
+
+  std::unique_ptr<Printer> printer = manager_->GetPrinter("Nope");
+  EXPECT_EQ(printer, nullptr);
+}
+
+}  // namespace
+}  // namespace chromeos

chrome/browser/chromeos/printing/printer_configurer.cc

diff --git a/chrome/browser/chromeos/printing/printer_configurer.cc b/chrome/browser/chromeos/printing/printer_configurer.cc
index 158abcdf..565000b 100644
--- a/chrome/browser/chromeos/printing/printer_configurer.cc
+++ b/chrome/browser/chromeos/printing/printer_configurer.cc
@@ -32,7 +32,10 @@
   // A mapping from filter names to available components for downloads.
   static const auto* const componentized_filters =
       new std::map<const std::string, const std::string>{
-          {"epson-escpr-wrapper", "epson-inkjet-printer-escpr"}};
+          {"epson-escpr-wrapper", "epson-inkjet-printer-escpr"},
+          {"epson-escpr", "epson-inkjet-printer-escpr"},
+          {"rastertostar", "star-cups-driver"},
+          {"rastertostarlm", "star-cups-driver"}};
   return *componentized_filters;
 }
 

chrome/browser/extensions/api/automation_internal/automation_event_router.cc

diff --git a/chrome/browser/extensions/api/automation_internal/automation_event_router.cc b/chrome/browser/extensions/api/automation_internal/automation_event_router.cc
index eb9f603..9b072fe 100644
--- a/chrome/browser/extensions/api/automation_internal/automation_event_router.cc
+++ b/chrome/browser/extensions/api/automation_internal/automation_event_router.cc
@@ -68,10 +68,8 @@
            true);
 }
 
-void AutomationEventRouter::DispatchAccessibilityEvents(
-    ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
-    const ui::AXTreeUpdate& update,
-    const std::vector<ExtensionMsg_AccessibilityEventParams>& events) {
+void AutomationEventRouter::DispatchAccessibilityEvent(
+    const ExtensionMsg_AccessibilityEventParams& params) {
   if (active_profile_ != ProfileManager::GetActiveUserProfile()) {
     active_profile_ = ProfileManager::GetActiveUserProfile();
     UpdateActiveProfile();
@@ -80,32 +78,32 @@
   for (const auto& listener : listeners_) {
     // Skip listeners that don't want to listen to this tree.
     if (!listener.desktop &&
-        listener.tree_ids.find(ax_tree_id) == listener.tree_ids.end()) {
+        listener.tree_ids.find(params.tree_id) == listener.tree_ids.end()) {
       continue;
     }
 
     content::RenderProcessHost* rph =
         content::RenderProcessHost::FromID(listener.process_id);
-    rph->Send(new ExtensionMsg_AccessibilityEvents(listener.routing_id,
-                                                   ax_tree_id, update, events,
-                                                   listener.is_active_profile));
+    rph->Send(new ExtensionMsg_AccessibilityEvent(listener.routing_id,
+                                                  params,
+                                                  listener.is_active_profile));
   }
 }
 
-void AutomationEventRouter::DispatchAccessibilityLocationChanges(
-    ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
-    const std::vector<ExtensionMsg_AccessibilityLocationChangeParams>& params) {
+void AutomationEventRouter::DispatchAccessibilityLocationChange(
+    const ExtensionMsg_AccessibilityLocationChangeParams& params) {
   for (const auto& listener : listeners_) {
     // Skip listeners that don't want to listen to this tree.
     if (!listener.desktop &&
-        listener.tree_ids.find(ax_tree_id) == listener.tree_ids.end()) {
+        listener.tree_ids.find(params.tree_id) == listener.tree_ids.end()) {
       continue;
     }
 
     content::RenderProcessHost* rph =
         content::RenderProcessHost::FromID(listener.process_id);
-    rph->Send(new ExtensionMsg_AccessibilityLocationChanges(
-        listener.routing_id, ax_tree_id, params));
+    rph->Send(new ExtensionMsg_AccessibilityLocationChange(
+        listener.routing_id,
+        params));
   }
 }
 

chrome/browser/extensions/api/automation_internal/automation_event_router.h

diff --git a/chrome/browser/extensions/api/automation_internal/automation_event_router.h b/chrome/browser/extensions/api/automation_internal/automation_event_router.h
index 9dae81f7..6edd9ec 100644
--- a/chrome/browser/extensions/api/automation_internal/automation_event_router.h
+++ b/chrome/browser/extensions/api/automation_internal/automation_event_router.h
@@ -15,7 +15,6 @@
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "extensions/common/extension_id.h"
-#include "ui/accessibility/ax_tree_id_registry.h"
 
 class Profile;
 
@@ -49,15 +48,11 @@
                                              int listener_process_id,
                                              int listener_routing_id);
 
-  void DispatchAccessibilityEvents(
-      ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
-      const ui::AXTreeUpdate& update,
-      const std::vector<ExtensionMsg_AccessibilityEventParams>& events);
+  void DispatchAccessibilityEvent(
+      const ExtensionMsg_AccessibilityEventParams& params);
 
-  void DispatchAccessibilityLocationChanges(
-      ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
-      const std::vector<ExtensionMsg_AccessibilityLocationChangeParams>&
-          params);
+  void DispatchAccessibilityLocationChange(
+      const ExtensionMsg_AccessibilityLocationChangeParams& params);
 
   // Notify all automation extensions that an accessibility tree was
   // destroyed. If |browser_context| is null,

chrome/browser/extensions/api/automation_internal/automation_internal_api.cc

diff --git a/chrome/browser/extensions/api/automation_internal/automation_internal_api.cc b/chrome/browser/extensions/api/automation_internal/automation_internal_api.cc
index 39cc6ab..366a9202 100644
--- a/chrome/browser/extensions/api/automation_internal/automation_internal_api.cc
+++ b/chrome/browser/extensions/api/automation_internal/automation_internal_api.cc
@@ -168,39 +168,36 @@
   ~AutomationWebContentsObserver() override {}
 
   // content::WebContentsObserver overrides.
-  void AccessibilityEventsReceived(
-      ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
-      const ui::AXTreeUpdate& update,
-      const std::vector<content::AXEventNotificationDetails>& events) override {
-    std::vector<ExtensionMsg_AccessibilityEventParams> dst_events;
-    for (const auto& event : events) {
-      ExtensionMsg_AccessibilityEventParams dst_event;
-      dst_event.id = event.id;
-      dst_event.event_type = event.event_type;
-      dst_event.event_from = event.event_from;
+  void AccessibilityEventReceived(
+      const std::vector<content::AXEventNotificationDetails>& details)
+      override {
+    for (const auto& event : details) {
+      ExtensionMsg_AccessibilityEventParams params;
+      params.tree_id = event.ax_tree_id;
+      params.id = event.id;
+      params.event_type = event.event_type;
+      params.update = event.update;
+      params.event_from = event.event_from;
 #if defined(USE_AURA)
-      dst_event.mouse_location =
-          aura::Env::GetInstance()->last_mouse_location();
+      params.mouse_location = aura::Env::GetInstance()->last_mouse_location();
 #endif
-      dst_events.push_back(dst_event);
+
+      AutomationEventRouter* router = AutomationEventRouter::GetInstance();
+      router->DispatchAccessibilityEvent(params);
     }
-    AutomationEventRouter* router = AutomationEventRouter::GetInstance();
-    router->DispatchAccessibilityEvents(ax_tree_id, update, dst_events);
   }
 
   void AccessibilityLocationChangesReceived(
-      ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
       const std::vector<content::AXLocationChangeNotificationDetails>& details)
       override {
-    std::vector<ExtensionMsg_AccessibilityLocationChangeParams> dst_details;
     for (const auto& src : details) {
       ExtensionMsg_AccessibilityLocationChangeParams dst;
       dst.id = src.id;
+      dst.tree_id = src.ax_tree_id;
       dst.new_location = src.new_location;
-      dst_details.push_back(dst);
+      AutomationEventRouter* router = AutomationEventRouter::GetInstance();
+      router->DispatchAccessibilityLocationChange(dst);
     }
-    AutomationEventRouter* router = AutomationEventRouter::GetInstance();
-    router->DispatchAccessibilityLocationChanges(ax_tree_id, dst_details);
   }
 
   void RenderFrameDeleted(
@@ -213,22 +210,22 @@
 
   void MediaStartedPlaying(const MediaPlayerInfo& video_type,
                            const MediaPlayerId& id) override {
-    ui::AXTreeUpdate update;
     std::vector<content::AXEventNotificationDetails> details;
     content::AXEventNotificationDetails detail;
+    detail.ax_tree_id = id.first->GetAXTreeID();
     detail.event_type = ui::AX_EVENT_MEDIA_STARTED_PLAYING;
     details.push_back(detail);
-    AccessibilityEventsReceived(id.first->GetAXTreeID(), update, details);
+    AccessibilityEventReceived(details);
   }
 
   void MediaStoppedPlaying(const MediaPlayerInfo& video_type,
                            const MediaPlayerId& id) override {
-    ui::AXTreeUpdate update;
     std::vector<content::AXEventNotificationDetails> details;
     content::AXEventNotificationDetails detail;
+    detail.ax_tree_id = id.first->GetAXTreeID();
     detail.event_type = ui::AX_EVENT_MEDIA_STOPPED_PLAYING;
     details.push_back(detail);
-    AccessibilityEventsReceived(id.first->GetAXTreeID(), update, details);
+    AccessibilityEventReceived(details);
   }
 
  private:
@@ -238,16 +235,16 @@
       : content::WebContentsObserver(web_contents),
         browser_context_(web_contents->GetBrowserContext()) {
     if (web_contents->WasRecentlyAudible()) {
+      std::vector<content::AXEventNotificationDetails> details;
       content::RenderFrameHost* rfh = web_contents->GetMainFrame();
       if (!rfh)
         return;
 
-      ui::AXTreeUpdate update;
-      std::vector<content::AXEventNotificationDetails> details;
       content::AXEventNotificationDetails detail;
+      detail.ax_tree_id = rfh->GetAXTreeID();
       detail.event_type = ui::AX_EVENT_MEDIA_STARTED_PLAYING;
       details.push_back(detail);
-      AccessibilityEventsReceived(rfh->GetAXTreeID(), update, details);
+      AccessibilityEventReceived(details);
     }
   }
 

chrome/browser/extensions/component_loader.cc

diff --git a/chrome/browser/extensions/component_loader.cc b/chrome/browser/extensions/component_loader.cc
index 86b03045..29f09a5 100644
--- a/chrome/browser/extensions/component_loader.cc
+++ b/chrome/browser/extensions/component_loader.cc
@@ -35,6 +35,7 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/common/content_switches.h"
+#include "extensions/browser/extension_file_task_runner.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_l10n_util.h"
@@ -85,7 +86,7 @@
 std::unique_ptr<base::DictionaryValue> LoadManifestOnFileThread(
     const base::FilePath& root_directory,
     const base::FilePath::CharType* manifest_filename) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
+  DCHECK(GetExtensionFileTaskRunner()->RunsTasksInCurrentSequence());
   std::string error;
   std::unique_ptr<base::DictionaryValue> manifest(
       file_util::LoadManifest(root_directory, manifest_filename, &error));
@@ -677,14 +678,12 @@
   const base::FilePath::CharType* manifest_filename =
       IsNormalSession() ? extensions::kManifestFilename
                         : extension_misc::kGuestManifestFilename;
-  BrowserThread::PostTaskAndReplyWithResult(
-      BrowserThread::FILE,
-      FROM_HERE,
+
+  base::PostTaskAndReplyWithResult(
+      GetExtensionFileTaskRunner().get(), FROM_HERE,
       base::Bind(&LoadManifestOnFileThread, root_directory, manifest_filename),
       base::Bind(&ComponentLoader::FinishAddComponentFromDir,
-                 weak_factory_.GetWeakPtr(),
-                 root_directory,
-                 extension_id,
+                 weak_factory_.GetWeakPtr(), root_directory, extension_id,
                  done_cb));
 }
 

chrome/browser/extensions/unpacked_installer.cc

diff --git a/chrome/browser/extensions/unpacked_installer.cc b/chrome/browser/extensions/unpacked_installer.cc
index 4d9ccaa..892f556 100644
--- a/chrome/browser/extensions/unpacked_installer.cc
+++ b/chrome/browser/extensions/unpacked_installer.cc
@@ -11,6 +11,7 @@
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
@@ -22,6 +23,7 @@
 #include "components/crx_file/id_util.h"
 #include "components/sync/model/string_ordinal.h"
 #include "content/public/browser/browser_thread.h"
+#include "extensions/browser/extension_file_task_runner.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/install/extension_install_ui.h"
@@ -129,9 +131,8 @@
 void UnpackedInstaller::Load(const base::FilePath& path_in) {
   DCHECK(extension_path_.empty());
   extension_path_ = path_in;
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::BindOnce(&UnpackedInstaller::GetAbsolutePath, this));
+  GetExtensionFileTaskRunner()->PostTask(
+      FROM_HERE, base::BindOnce(&UnpackedInstaller::GetAbsolutePath, this));
 }
 
 bool UnpackedInstaller::LoadFromCommandLine(const base::FilePath& path_in,
@@ -301,7 +302,7 @@
 }
 
 void UnpackedInstaller::GetAbsolutePath() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   extension_path_ = base::MakeAbsoluteFilePath(extension_path_);
 
@@ -328,13 +329,13 @@
     return;
   }
 
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
+  GetExtensionFileTaskRunner()->PostTask(
+      FROM_HERE,
       base::BindOnce(&UnpackedInstaller::LoadWithFileAccess, this, GetFlags()));
 }
 
 void UnpackedInstaller::LoadWithFileAccess(int flags) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  base::ThreadRestrictions::AssertIOAllowed();
 
   std::string error;
   extension_ = file_util::LoadExtension(extension_path_, Manifest::UNPACKED,

chrome/browser/extensions/user_script_listener_unittest.cc

diff --git a/chrome/browser/extensions/user_script_listener_unittest.cc b/chrome/browser/extensions/user_script_listener_unittest.cc
index 6829eed..ae9c4ce 100644
--- a/chrome/browser/extensions/user_script_listener_unittest.cc
+++ b/chrome/browser/extensions/user_script_listener_unittest.cc
@@ -24,6 +24,7 @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "extensions/browser/extension_registry.h"
 #include "net/base/request_priority.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
@@ -206,6 +207,7 @@
         .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
         .AppendASCII("1.0.0.0");
     UnpackedInstaller::Create(service_)->Load(extension_path);
+    content::RunAllBlockingPoolTasksUntilIdle();
   }
 
   void UnloadTestExtension() {
@@ -230,7 +232,6 @@
 
 TEST_F(UserScriptListenerTest, DelayAndUpdate) {
   LoadTestExtension();
-  base::RunLoop().RunUntilIdle();
 
   net::TestDelegate delegate;
   net::TestURLRequestContext context;
@@ -248,7 +249,6 @@
 
 TEST_F(UserScriptListenerTest, DelayAndUnload) {
   LoadTestExtension();
-  base::RunLoop().RunUntilIdle();
 
   net::TestDelegate delegate;
   net::TestURLRequestContext context;
@@ -286,7 +286,6 @@
 
 TEST_F(UserScriptListenerTest, NoDelayNotMatching) {
   LoadTestExtension();
-  base::RunLoop().RunUntilIdle();
 
   net::TestDelegate delegate;
   net::TestURLRequestContext context;
@@ -302,7 +301,6 @@
 
 TEST_F(UserScriptListenerTest, MultiProfile) {
   LoadTestExtension();
-  base::RunLoop().RunUntilIdle();
 
   // Fire up a second profile and have it load an extension with a content
   // script.
@@ -348,7 +346,6 @@
 // throttles.
 TEST_F(UserScriptListenerTest, ResumeBeforeStart) {
   LoadTestExtension();
-  base::RunLoop().RunUntilIdle();
   net::TestDelegate delegate;
   net::TestURLRequestContext context;
   GURL url(kMatchingUrl);

chrome/browser/extensions/webstore_installer.cc

diff --git a/chrome/browser/extensions/webstore_installer.cc b/chrome/browser/extensions/webstore_installer.cc
index a8d9de7..84abd9b 100644
--- a/chrome/browser/extensions/webstore_installer.cc
+++ b/chrome/browser/extensions/webstore_installer.cc
@@ -24,6 +24,8 @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ -55,6 +57,7 @@
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
+#include "extensions/browser/extension_file_task_runner.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/install/crx_install_error.h"
@@ -109,19 +112,14 @@
 
 base::FilePath* g_download_directory_for_tests = NULL;
 
-// Must be executed on the FILE thread.
-void GetDownloadFilePath(
-    const base::FilePath& download_directory,
-    const std::string& id,
-    const base::Callback<void(const base::FilePath&)>& callback) {
+base::FilePath GetDownloadFilePath(const base::FilePath& download_directory,
+                                   const std::string& id) {
+  base::ThreadRestrictions::AssertIOAllowed();
   // Ensure the download directory exists. TODO(asargent) - make this use
   // common code from the downloads system.
-  if (!base::DirectoryExists(download_directory)) {
-    if (!base::CreateDirectory(download_directory)) {
-      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                              base::BindOnce(callback, base::FilePath()));
-      return;
-    }
+  if (!base::DirectoryExists(download_directory) &&
+      !base::CreateDirectory(download_directory)) {
+    return base::FilePath();
   }
 
   // This is to help avoid a race condition between when we generate this
@@ -141,8 +139,7 @@
         base::StringPrintf(" (%d)", uniquifier));
   }
 
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::BindOnce(callback, file));
+  return file;
 }
 
 void MaybeAppendAuthUserParameter(const std::string& authuser, GURL* url) {
@@ -601,11 +598,10 @@
   }
 #endif
 
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::BindOnce(
-          &GetDownloadFilePath, download_directory, extension_id,
-          base::Bind(&WebstoreInstaller::StartDownload, this, extension_id)));
+  base::PostTaskAndReplyWithResult(
+      GetExtensionFileTaskRunner().get(), FROM_HERE,
+      base::BindOnce(&GetDownloadFilePath, download_directory, extension_id),
+      base::BindOnce(&WebstoreInstaller::StartDownload, this, extension_id));
 }
 
 // http://crbug.com/165634

chrome/browser/extensions/zipfile_installer.cc

diff --git a/chrome/browser/extensions/zipfile_installer.cc b/chrome/browser/extensions/zipfile_installer.cc
index 7b08e6d..da3a2e99 100644
--- a/chrome/browser/extensions/zipfile_installer.cc
+++ b/chrome/browser/extensions/zipfile_installer.cc
@@ -6,12 +6,14 @@
 
 #include "base/files/file_util.h"
 #include "base/path_service.h"
+#include "base/task_scheduler/post_task.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
+#include "extensions/browser/extension_file_task_runner.h"
 #include "extensions/common/extension_unpacker.mojom.h"
 #include "ui/base/l10n/l10n_util.h"
 
@@ -22,6 +24,23 @@
 const char kExtensionHandlerFileUnzipError[] =
     "Could not unzip extension for install.";
 
+base::Optional<base::FilePath> PrepareAndGetUnzipDir(
+    const base::FilePath& zip_file) {
+  base::ThreadRestrictions::AssertIOAllowed();
+
+  base::FilePath dir_temp;
+  base::PathService::Get(base::DIR_TEMP, &dir_temp);
+
+  base::FilePath::StringType dir_name =
+      zip_file.RemoveExtension().BaseName().value() + FILE_PATH_LITERAL("_");
+
+  base::FilePath unzip_dir;
+  if (!base::CreateTemporaryDirInDir(dir_temp, dir_name, &unzip_dir))
+    return base::Optional<base::FilePath>();
+
+  return unzip_dir;
+}
+
 }  // namespace
 
 namespace extensions {
@@ -39,9 +58,10 @@
 
   zip_file_ = zip_file;
 
-  content::BrowserThread::PostTask(
-      content::BrowserThread::FILE, FROM_HERE,
-      base::BindOnce(&ZipFileInstaller::PrepareUnzipDir, this, zip_file));
+  base::PostTaskAndReplyWithResult(
+      GetExtensionFileTaskRunner().get(), FROM_HERE,
+      base::BindOnce(&PrepareAndGetUnzipDir, zip_file),
+      base::BindOnce(&ZipFileInstaller::Unzip, this));
 }
 
 ZipFileInstaller::ZipFileInstaller(ExtensionService* service)
@@ -50,46 +70,27 @@
 
 ZipFileInstaller::~ZipFileInstaller() = default;
 
-void ZipFileInstaller::PrepareUnzipDir(const base::FilePath& zip_file) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
-
-  base::FilePath dir_temp;
-  base::PathService::Get(base::DIR_TEMP, &dir_temp);
-
-  base::FilePath::StringType dir_name =
-      zip_file.RemoveExtension().BaseName().value() + FILE_PATH_LITERAL("_");
-
-  base::FilePath unzip_dir;
-  if (!base::CreateTemporaryDirInDir(dir_temp, dir_name, &unzip_dir)) {
-    content::BrowserThread::PostTask(
-        content::BrowserThread::UI, FROM_HERE,
-        base::BindOnce(&ZipFileInstaller::ReportFailure, this,
-                       std::string(kExtensionHandlerTempDirError)));
+void ZipFileInstaller::Unzip(base::Optional<base::FilePath> unzip_dir) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (!unzip_dir) {
+    ReportFailure(std::string(kExtensionHandlerTempDirError));
     return;
   }
-
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI, FROM_HERE,
-      base::BindOnce(&ZipFileInstaller::Unzip, this, unzip_dir));
-}
-
-void ZipFileInstaller::Unzip(const base::FilePath& unzip_dir) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(!utility_process_mojo_client_);
 
   utility_process_mojo_client_ = base::MakeUnique<
       content::UtilityProcessMojoClient<mojom::ExtensionUnpacker>>(
       l10n_util::GetStringUTF16(IDS_UTILITY_PROCESS_ZIP_FILE_INSTALLER_NAME));
   utility_process_mojo_client_->set_error_callback(
-      base::Bind(&ZipFileInstaller::UnzipDone, this, unzip_dir, false));
+      base::Bind(&ZipFileInstaller::UnzipDone, this, *unzip_dir, false));
 
-  utility_process_mojo_client_->set_exposed_directory(unzip_dir);
+  utility_process_mojo_client_->set_exposed_directory(*unzip_dir);
 
   utility_process_mojo_client_->Start();
 
   utility_process_mojo_client_->service()->Unzip(
-      zip_file_, unzip_dir,
-      base::Bind(&ZipFileInstaller::UnzipDone, this, unzip_dir));
+      zip_file_, *unzip_dir,
+      base::Bind(&ZipFileInstaller::UnzipDone, this, *unzip_dir));
 }
 
 void ZipFileInstaller::UnzipDone(const base::FilePath& unzip_dir,

chrome/browser/extensions/zipfile_installer.h

diff --git a/chrome/browser/extensions/zipfile_installer.h b/chrome/browser/extensions/zipfile_installer.h
index 608885c..28d5407 100644
--- a/chrome/browser/extensions/zipfile_installer.h
+++ b/chrome/browser/extensions/zipfile_installer.h
@@ -40,8 +40,7 @@
   ~ZipFileInstaller();
 
   // Unzip an extension into |unzip_dir| and load it with an UnpackedInstaller.
-  void PrepareUnzipDir(const base::FilePath& zip_file);
-  void Unzip(const base::FilePath& unzip_dir);
+  void Unzip(base::Optional<base::FilePath> unzip_dir);
   void UnzipDone(const base::FilePath& unzip_dir, bool success);
 
   // On failure, report the |error| reason.

chrome/browser/media/webrtc/media_stream_capture_indicator.cc

diff --git a/chrome/browser/media/webrtc/media_stream_capture_indicator.cc b/chrome/browser/media/webrtc/media_stream_capture_indicator.cc
index 410dd3b8..bebf5ea 100644
--- a/chrome/browser/media/webrtc/media_stream_capture_indicator.cc
+++ b/chrome/browser/media/webrtc/media_stream_capture_indicator.cc
@@ -13,14 +13,12 @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
-#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/status_icons/status_icon.h"
 #include "chrome/browser/status_icons/status_tray.h"
 #include "chrome/browser/tab_contents/tab_util.h"
-#include "chrome/grit/chromium_strings.h"
-#include "chrome/grit/theme_resources.h"
 #include "components/url_formatter/elide_url.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
@@ -28,11 +26,18 @@
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "extensions/features/features.h"
-#include "ui/base/l10n/l10n_util.h"
-#include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_skia.h"
 
+#if !defined(OS_ANDROID)
+#include "chrome/grit/chromium_strings.h"
+#include "components/vector_icons/vector_icons.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "ui/gfx/color_palette.h"
+#include "ui/gfx/paint_vector_icon.h"
+#endif
+
 #if BUILDFLAG(ENABLE_EXTENSIONS)
+#include "base/strings/utf_string_conversions.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
@@ -239,11 +244,7 @@
   }
 }
 
-MediaStreamCaptureIndicator::MediaStreamCaptureIndicator()
-    : status_icon_(NULL),
-      mic_image_(NULL),
-      camera_image_(NULL) {
-}
+MediaStreamCaptureIndicator::MediaStreamCaptureIndicator() {}
 
 MediaStreamCaptureIndicator::~MediaStreamCaptureIndicator() {
   // The user is responsible for cleaning up by reporting the closure of any
@@ -342,8 +343,6 @@
   if (!status_tray)
     return;
 
-  EnsureStatusTrayIconResources();
-
   gfx::ImageSkia image;
   base::string16 tool_tip;
   GetStatusTrayIconInfo(audio, video, &image, &tool_tip);
@@ -354,22 +353,6 @@
       StatusTray::MEDIA_STREAM_CAPTURE_ICON, image, tool_tip);
 }
 
-void MediaStreamCaptureIndicator::EnsureStatusTrayIconResources() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  // TODO(estade): these should use vector icons.
-  if (!mic_image_) {
-    mic_image_ = ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-        IDR_INFOBAR_MEDIA_STREAM_MIC);
-  }
-  if (!camera_image_) {
-    camera_image_ = ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-        IDR_INFOBAR_MEDIA_STREAM_CAMERA);
-  }
-  DCHECK(mic_image_);
-  DCHECK(camera_image_);
-}
-
 void MediaStreamCaptureIndicator::MaybeDestroyStatusTrayIcon() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
@@ -445,22 +428,28 @@
     bool video,
     gfx::ImageSkia* image,
     base::string16* tool_tip) {
+#if defined(OS_ANDROID)
+  NOTREACHED();
+#else   // !defined(OS_ANDROID)
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(audio || video);
   DCHECK(image);
   DCHECK(tool_tip);
 
   int message_id = 0;
+  const gfx::VectorIcon* icon = nullptr;
   if (audio && video) {
     message_id = IDS_MEDIA_STREAM_STATUS_TRAY_TEXT_AUDIO_AND_VIDEO;
-    *image = *camera_image_;
+    icon = &vector_icons::kVideocamIcon;
   } else if (audio && !video) {
     message_id = IDS_MEDIA_STREAM_STATUS_TRAY_TEXT_AUDIO_ONLY;
-    *image = *mic_image_;
+    icon = &vector_icons::kMicrophoneIcon;
   } else if (!audio && video) {
     message_id = IDS_MEDIA_STREAM_STATUS_TRAY_TEXT_VIDEO_ONLY;
-    *image = *camera_image_;
+    icon = &vector_icons::kVideocamIcon;
   }
 
   *tool_tip = l10n_util::GetStringUTF16(message_id);
+  *image = gfx::CreateVectorIcon(*icon, 16, gfx::kChromeIconGrey);
+#endif  // !defined(OS_ANDROID)
 }

chrome/browser/media/webrtc/media_stream_capture_indicator.h

diff --git a/chrome/browser/media/webrtc/media_stream_capture_indicator.h b/chrome/browser/media/webrtc/media_stream_capture_indicator.h
index 66c88a7..0bf472f 100644
--- a/chrome/browser/media/webrtc/media_stream_capture_indicator.h
+++ b/chrome/browser/media/webrtc/media_stream_capture_indicator.h
@@ -89,11 +89,7 @@
 
   // Reference to our status icon - owned by the StatusTray. If null,
   // the platform doesn't support status icons.
-  StatusIcon* status_icon_;
-
-  // These images are owned by ResourceBundle and need not be destroyed.
-  gfx::ImageSkia* mic_image_;
-  gfx::ImageSkia* camera_image_;
+  StatusIcon* status_icon_ = nullptr;
 
   // A map that contains the usage counts of the opened capture devices for each
   // WebContents instance.

chrome/browser/media/webrtc/media_stream_devices_controller.cc

diff --git a/chrome/browser/media/webrtc/media_stream_devices_controller.cc b/chrome/browser/media/webrtc/media_stream_devices_controller.cc
index 11bd8a4..5534f9c2 100644
--- a/chrome/browser/media/webrtc/media_stream_devices_controller.cc
+++ b/chrome/browser/media/webrtc/media_stream_devices_controller.cc
@@ -44,11 +44,11 @@
 #if defined(OS_ANDROID)
 #include <vector>
 
+#include "chrome/browser/android/android_theme_resources.h"
 #include "chrome/browser/android/preferences/pref_service_bridge.h"
 #include "chrome/browser/media/webrtc/media_stream_infobar_delegate_android.h"
 #include "chrome/browser/permissions/permission_dialog_delegate.h"
 #include "chrome/browser/permissions/permission_update_infobar_delegate_android.h"
-#include "chrome/grit/theme_resources.h"
 #include "ui/android/window_android.h"
 #else  // !defined(OS_ANDROID)
 #include "components/vector_icons/vector_icons.h"
@@ -164,8 +164,8 @@
 PermissionRequest::IconId MediaStreamDevicesController::Request::GetIconId()
     const {
 #if defined(OS_ANDROID)
-  return IsAskingForVideo() ? IDR_INFOBAR_MEDIA_STREAM_CAMERA
-                            : IDR_INFOBAR_MEDIA_STREAM_MIC;
+  return IsAskingForVideo() ? IDR_ANDROID_INFOBAR_MEDIA_STREAM_CAMERA
+                            : IDR_ANDROID_INFOBAR_MEDIA_STREAM_MIC;
 #else
   return IsAskingForVideo() ? vector_icons::kVideocamIcon
                             : vector_icons::kMicrophoneIcon;

chrome/browser/media/webrtc/media_stream_infobar_delegate_android.cc

diff --git a/chrome/browser/media/webrtc/media_stream_infobar_delegate_android.cc b/chrome/browser/media/webrtc/media_stream_infobar_delegate_android.cc
index 02f9272..6b1d84d 100644
--- a/chrome/browser/media/webrtc/media_stream_infobar_delegate_android.cc
+++ b/chrome/browser/media/webrtc/media_stream_infobar_delegate_android.cc
@@ -10,12 +10,12 @@
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/android/android_theme_resources.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/permissions/permission_uma_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
-#include "chrome/grit/theme_resources.h"
 #include "components/content_settings/core/common/content_settings_types.h"
 #include "components/google/core/browser/google_util.h"
 #include "components/infobars/core/infobar.h"
@@ -71,8 +71,8 @@
 }
 
 int MediaStreamInfoBarDelegateAndroid::GetIconId() const {
-  return request_->IsAskingForVideo() ? IDR_INFOBAR_MEDIA_STREAM_CAMERA
-                                      : IDR_INFOBAR_MEDIA_STREAM_MIC;
+  return request_->IsAskingForVideo() ? IDR_ANDROID_INFOBAR_MEDIA_STREAM_CAMERA
+                                      : IDR_ANDROID_INFOBAR_MEDIA_STREAM_MIC;
 }
 
 MediaStreamInfoBarDelegateAndroid::MediaStreamInfoBarDelegateAndroid(

chrome/browser/offline_pages/prefetch/prefetch_instance_id_proxy.cc

diff --git a/chrome/browser/offline_pages/prefetch/prefetch_instance_id_proxy.cc b/chrome/browser/offline_pages/prefetch/prefetch_instance_id_proxy.cc
index c55cc11..d478a86 100644
--- a/chrome/browser/offline_pages/prefetch/prefetch_instance_id_proxy.cc
+++ b/chrome/browser/offline_pages/prefetch/prefetch_instance_id_proxy.cc
@@ -23,9 +23,7 @@
 namespace {
 
 const char kScopeGCM[] = "GCM";
-
-// TODO(dewittj): Add prod sender ID when finalized.
-const char kStagingSenderId[] = "208433663017";
+const char kProdSenderId[] = "864229763856";
 
 }  // namespace
 
@@ -57,7 +55,7 @@
   InstanceID* instance_id = service->driver()->GetInstanceID(app_id_);
   DCHECK(instance_id);
 
-  instance_id->GetToken(kStagingSenderId, kScopeGCM,
+  instance_id->GetToken(kProdSenderId, kScopeGCM,
                         std::map<std::string, std::string>(),
                         base::Bind(&PrefetchInstanceIDProxy::GotGCMToken,
                                    weak_factory_.GetWeakPtr(), callback));

chrome/browser/password_manager/generated_password_saved_infobar_delegate_android.cc

diff --git a/chrome/browser/password_manager/generated_password_saved_infobar_delegate_android.cc b/chrome/browser/password_manager/generated_password_saved_infobar_delegate_android.cc
index 915d423..ceffdce 100644
--- a/chrome/browser/password_manager/generated_password_saved_infobar_delegate_android.cc
+++ b/chrome/browser/password_manager/generated_password_saved_infobar_delegate_android.cc
@@ -7,9 +7,9 @@
 #include <stddef.h>
 
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/android/android_theme_resources.h"
 #include "chrome/browser/android/preferences/preferences_launcher.h"
 #include "chrome/grit/generated_resources.h"
-#include "chrome/grit/theme_resources.h"
 #include "components/infobars/core/infobar_delegate.h"
 #include "components/password_manager/core/browser/password_bubble_experiment.h"
 #include "components/password_manager/core/browser/password_manager_constants.h"
@@ -45,5 +45,5 @@
 }
 
 int GeneratedPasswordSavedInfoBarDelegateAndroid::GetIconId() const {
-  return IDR_INFOBAR_SAVE_PASSWORD;
+  return IDR_ANDROID_INFOBAR_SAVE_PASSWORD;
 }

chrome/browser/password_manager/password_manager_infobar_delegate_android.cc

diff --git a/chrome/browser/password_manager/password_manager_infobar_delegate_android.cc b/chrome/browser/password_manager/password_manager_infobar_delegate_android.cc
index c9c81c0..777c8521 100644
--- a/chrome/browser/password_manager/password_manager_infobar_delegate_android.cc
+++ b/chrome/browser/password_manager/password_manager_infobar_delegate_android.cc
@@ -4,8 +4,8 @@
 
 #include "chrome/browser/password_manager/password_manager_infobar_delegate_android.h"
 
+#include "chrome/browser/android/android_theme_resources.h"
 #include "chrome/browser/infobars/infobar_service.h"
-#include "chrome/grit/theme_resources.h"
 #include "components/infobars/core/infobar.h"
 #include "components/password_manager/core/browser/password_manager_constants.h"
 #include "content/public/browser/web_contents.h"
@@ -26,7 +26,7 @@
 }
 
 int PasswordManagerInfoBarDelegate::GetIconId() const {
-  return IDR_INFOBAR_SAVE_PASSWORD;
+  return IDR_ANDROID_INFOBAR_SAVE_PASSWORD;
 }
 
 bool PasswordManagerInfoBarDelegate::ShouldExpire(

chrome/browser/permissions/permission_prompt_android.cc

diff --git a/chrome/browser/permissions/permission_prompt_android.cc b/chrome/browser/permissions/permission_prompt_android.cc
index d7f88160..ff26d15 100644
--- a/chrome/browser/permissions/permission_prompt_android.cc
+++ b/chrome/browser/permissions/permission_prompt_android.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/permissions/permission_prompt_android.h"
 
 #include "base/memory/ptr_util.h"
+#include "chrome/browser/android/android_theme_resources.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/permissions/grouped_permission_infobar_delegate_android.h"
 #include "chrome/browser/permissions/permission_dialog_delegate.h"
@@ -12,7 +13,6 @@
 #include "chrome/browser/permissions/permission_uma_util.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
-#include "chrome/grit/theme_resources.h"
 #include "components/strings/grit/components_strings.h"
 #include "components/url_formatter/elide_url.h"
 #include "ui/base/l10n/l10n_util.h"
@@ -128,7 +128,7 @@
   if (requests.size() == 1)
     return requests[0]->GetIconId();
   CheckValidRequestGroup(requests);
-  return IDR_INFOBAR_MEDIA_STREAM_CAMERA;
+  return IDR_ANDROID_INFOBAR_MEDIA_STREAM_CAMERA;
 }
 
 base::string16 PermissionPromptAndroid::GetMessageText() const {

chrome/browser/permissions/permission_request_impl.cc

diff --git a/chrome/browser/permissions/permission_request_impl.cc b/chrome/browser/permissions/permission_request_impl.cc
index b2459af3..a2588b3 100644
--- a/chrome/browser/permissions/permission_request_impl.cc
+++ b/chrome/browser/permissions/permission_request_impl.cc
@@ -9,7 +9,6 @@
 #include "chrome/browser/permissions/permission_uma_util.h"
 #include "chrome/browser/permissions/permission_util.h"
 #include "chrome/grit/generated_resources.h"
-#include "chrome/grit/theme_resources.h"
 #include "components/url_formatter/elide_url.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
@@ -66,9 +65,9 @@
     case CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER:
       return IDR_ANDROID_INFOBAR_PROTECTED_MEDIA_IDENTIFIER;
     case CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC:
-      return IDR_INFOBAR_MEDIA_STREAM_MIC;
+      return IDR_ANDROID_INFOBAR_MEDIA_STREAM_MIC;
     case CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA:
-      return IDR_INFOBAR_MEDIA_STREAM_CAMERA;
+      return IDR_ANDROID_INFOBAR_MEDIA_STREAM_CAMERA;
     default:
       NOTREACHED();
       return IDR_ANDROID_INFOBAR_WARNING;

chrome/browser/printing/print_view_manager_base.cc

diff --git a/chrome/browser/printing/print_view_manager_base.cc b/chrome/browser/printing/print_view_manager_base.cc
index dd302e3..17961d3 100644
--- a/chrome/browser/printing/print_view_manager_base.cc
+++ b/chrome/browser/printing/print_view_manager_base.cc
@@ -274,6 +274,19 @@
   }
 }
 
+#if defined(OS_WIN) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
+void PrintViewManagerBase::SystemDialogCancelled() {
+  // System dialog was cancelled. Clean up the print job and notify the
+  // BackgroundPrintingManager.
+  ReleasePrinterQuery();
+  TerminatePrintJob(true);
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_PRINT_JOB_RELEASED,
+      content::Source<content::WebContents>(web_contents()),
+      content::NotificationService::NoDetails());
+}
+#endif
+
 bool PrintViewManagerBase::OnMessageReceived(
     const IPC::Message& message,
     content::RenderFrameHost* render_frame_host) {

chrome/browser/printing/print_view_manager_base.h

diff --git a/chrome/browser/printing/print_view_manager_base.h b/chrome/browser/printing/print_view_manager_base.h
index c54ba76e..ee19939c 100644
--- a/chrome/browser/printing/print_view_manager_base.h
+++ b/chrome/browser/printing/print_view_manager_base.h
@@ -48,6 +48,12 @@
   // Whether printing is enabled or not.
   void UpdatePrintingEnabled();
 
+// Notifies the print view manager that the system dialog has been cancelled
+// after being opened from Print Preview.
+#if defined(OS_WIN) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
+  void SystemDialogCancelled();
+#endif
+
   // PrintedPagesSource implementation.
   base::string16 RenderSourceName() override;
 

chrome/browser/printing/printing_message_filter.cc

diff --git a/chrome/browser/printing/printing_message_filter.cc b/chrome/browser/printing/printing_message_filter.cc
index 8c9c449..ad72c5f 100644
--- a/chrome/browser/printing/printing_message_filter.cc
+++ b/chrome/browser/printing/printing_message_filter.cc
@@ -13,6 +13,7 @@
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/printing/print_job_manager.h"
+#include "chrome/browser/printing/print_view_manager.h"
 #include "chrome/browser/printing/printer_query.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
@@ -60,7 +61,7 @@
   DISALLOW_COPY_AND_ASSIGN(ShutdownNotifierFactory);
 };
 
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || (defined(OS_WIN) && BUILDFLAG(ENABLE_PRINT_PREVIEW))
 content::WebContents* GetWebContentsForRenderFrame(int render_process_id,
                                                    int render_frame_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ -69,6 +70,7 @@
   return frame ? content::WebContents::FromRenderFrameHost(frame) : nullptr;
 }
 
+#if defined(OS_ANDROID)
 PrintViewManagerBasic* GetPrintManager(int render_process_id,
                                        int render_frame_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ -77,7 +79,18 @@
   return web_contents ? PrintViewManagerBasic::FromWebContents(web_contents)
                       : nullptr;
 }
+#else  // defined(OS_WIN) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
+PrintViewManager* GetPrintViewManager(int render_process_id,
+                                      int render_frame_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  content::WebContents* web_contents =
+      GetWebContentsForRenderFrame(render_process_id, render_frame_id);
+  return web_contents ? PrintViewManager::FromWebContents(web_contents)
+                      : nullptr;
+}
 #endif
+#endif  // defined(OS_ANDROID) || (defined(OS_WIN) &&
+        // BUILDFLAG(ENABLE_PRINT_PREVIEW))
 
 }  // namespace
 
@@ -309,6 +322,14 @@
                  printer_query, reply_msg));
 }
 
+#if defined(OS_WIN) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
+void PrintingMessageFilter::NotifySystemDialogCancelled(int routing_id) {
+  PrintViewManager* manager =
+      GetPrintViewManager(render_process_id_, routing_id);
+  manager->SystemDialogCancelled();
+}
+#endif
+
 void PrintingMessageFilter::OnUpdatePrintSettingsReply(
     scoped_refptr<PrinterQuery> printer_query,
     IPC::Message* reply_msg) {
@@ -323,6 +344,15 @@
   }
   bool canceled = printer_query.get() &&
                   (printer_query->last_status() == PrintingContext::CANCEL);
+#if defined(OS_WIN) && BUILDFLAG(ENABLE_PRINT_PREVIEW)
+  if (canceled) {
+    int routing_id = reply_msg->routing_id();
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&PrintingMessageFilter::NotifySystemDialogCancelled, this,
+                   routing_id));
+  }
+#endif
   PrintHostMsg_UpdatePrintSettings::WriteReplyParams(reply_msg, params,
                                                      canceled);
   Send(reply_msg);

chrome/browser/printing/printing_message_filter.h

diff --git a/chrome/browser/printing/printing_message_filter.h b/chrome/browser/printing/printing_message_filter.h
index 3402f25..3b85fff 100644
--- a/chrome/browser/printing/printing_message_filter.h
+++ b/chrome/browser/printing/printing_message_filter.h
@@ -96,6 +96,9 @@
   void OnCheckForCancel(int32_t preview_ui_id,
                         int preview_request_id,
                         bool* cancel);
+#if defined(OS_WIN)
+  void NotifySystemDialogCancelled(int routing_id);
+#endif
 #endif
 
   std::unique_ptr<KeyedServiceShutdownNotifier::Subscription>

chrome/browser/ui/BUILD.gn

diff --git a/chrome/browser/ui/BUILD.gn b/chrome/browser/ui/BUILD.gn
index a68303b3..98c274a 100644
--- a/chrome/browser/ui/BUILD.gn
+++ b/chrome/browser/ui/BUILD.gn
@@ -2867,6 +2867,8 @@
         "cocoa/fullscreen/immersive_fullscreen_controller.mm",
         "cocoa/fullscreen_low_power_coordinator.h",
         "cocoa/fullscreen_low_power_coordinator.mm",
+        "cocoa/fullscreen_placeholder_view.h",
+        "cocoa/fullscreen_placeholder_view.mm",
         "cocoa/fullscreen_window.h",
         "cocoa/fullscreen_window.mm",
         "cocoa/global_error_bubble_controller.h",

chrome/browser/ui/ash/chrome_launcher_prefs.cc

diff --git a/chrome/browser/ui/ash/chrome_launcher_prefs.cc b/chrome/browser/ui/ash/chrome_launcher_prefs.cc
index 21a7c26..3a13dfc5 100644
--- a/chrome/browser/ui/ash/chrome_launcher_prefs.cc
+++ b/chrome/browser/ui/ash/chrome_launcher_prefs.cc
@@ -269,10 +269,13 @@
 ChromeLauncherPrefsObserver::CreateIfNecessary(Profile* profile) {
   sync_preferences::PrefServiceSyncable* prefs =
       PrefServiceSyncableFromProfile(profile);
-  if (!prefs->FindPreference(ash::prefs::kShelfAlignmentLocal)
-           ->HasUserSetting() ||
-      !prefs->FindPreference(ash::prefs::kShelfAutoHideBehaviorLocal)
-           ->HasUserSetting()) {
+  const PrefService::Preference* alignment_preference =
+      prefs->FindPreference(ash::prefs::kShelfAlignmentLocal);
+  const PrefService::Preference* auto_hide_preference =
+      prefs->FindPreference(ash::prefs::kShelfAutoHideBehaviorLocal);
+  // TODO(crbug.com/753823): Ash prefs may not yet be registered in chrome.
+  if ((alignment_preference && !alignment_preference->HasUserSetting()) ||
+      (auto_hide_preference && !auto_hide_preference->HasUserSetting())) {
     return base::WrapUnique(new ChromeLauncherPrefsObserver(prefs));
   }
   return nullptr;

chrome/browser/ui/aura/accessibility/automation_manager_aura.cc

diff --git a/chrome/browser/ui/aura/accessibility/automation_manager_aura.cc b/chrome/browser/ui/aura/accessibility/automation_manager_aura.cc
index ba38c773..658012d 100644
--- a/chrome/browser/ui/aura/accessibility/automation_manager_aura.cc
+++ b/chrome/browser/ui/aura/accessibility/automation_manager_aura.cc
@@ -150,8 +150,8 @@
   }
   processing_events_ = true;
 
-  ui::AXTreeUpdate update;
-  if (!current_tree_serializer_->SerializeChanges(aura_obj, &update)) {
+  ExtensionMsg_AccessibilityEventParams params;
+  if (!current_tree_serializer_->SerializeChanges(aura_obj, &params.update)) {
     LOG(ERROR) << "Unable to serialize one accessibility event.";
     return;
   }
@@ -160,18 +160,14 @@
   views::AXAuraObjWrapper* focus =
       views::AXAuraObjCache::GetInstance()->GetFocus();
   if (focus)
-    current_tree_serializer_->SerializeChanges(focus, &update);
+    current_tree_serializer_->SerializeChanges(focus, &params.update);
 
-  std::vector<ExtensionMsg_AccessibilityEventParams> events;
-  ExtensionMsg_AccessibilityEventParams event;
-  event.id = aura_obj->GetID();
-  event.event_type = event_type;
-  event.mouse_location = aura::Env::GetInstance()->last_mouse_location();
-  events.push_back(event);
-
+  params.tree_id = 0;
+  params.id = aura_obj->GetID();
+  params.event_type = event_type;
+  params.mouse_location = aura::Env::GetInstance()->last_mouse_location();
   AutomationEventRouter* router = AutomationEventRouter::GetInstance();
-  router->DispatchAccessibilityEvents(
-      extensions::api::automation::kDesktopTreeID, update, events);
+  router->DispatchAccessibilityEvent(params);
 
   processing_events_ = false;
   auto pending_events_copy = pending_events_;

chrome/browser/ui/cocoa/browser_window_controller.mm

diff --git a/chrome/browser/ui/cocoa/browser_window_controller.mm b/chrome/browser/ui/cocoa/browser_window_controller.mm
index 38acfd7..198b67cc 100644
--- a/chrome/browser/ui/cocoa/browser_window_controller.mm
+++ b/chrome/browser/ui/cocoa/browser_window_controller.mm
@@ -62,6 +62,7 @@
 #import "chrome/browser/ui/cocoa/fullscreen/fullscreen_toolbar_controller.h"
 #import "chrome/browser/ui/cocoa/fullscreen/fullscreen_toolbar_visibility_lock_controller.h"
 #include "chrome/browser/ui/cocoa/fullscreen_low_power_coordinator.h"
+#include "chrome/browser/ui/cocoa/fullscreen_placeholder_view.h"
 #import "chrome/browser/ui/cocoa/fullscreen_window.h"
 #import "chrome/browser/ui/cocoa/infobars/infobar_container_controller.h"
 #include "chrome/browser/ui/cocoa/l10n_util.h"
@@ -88,6 +89,7 @@
 #include "chrome/browser/ui/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/ui/translate/translate_bubble_model_impl.h"
 #include "chrome/browser/ui/window_sizer/window_sizer.h"
+#include "chrome/common/chrome_features.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/command.h"
 #include "chrome/common/pref_names.h"
@@ -111,6 +113,7 @@
 #include "ui/display/screen.h"
 #import "ui/gfx/mac/coordinate_conversion.h"
 #include "ui/gfx/mac/scoped_cocoa_disable_screen_updates.h"
+#include "ui/gfx/scrollbar_size.h"
 
 using bookmarks::BookmarkModel;
 using bookmarks::BookmarkNode;
@@ -1999,6 +2002,35 @@
   // that the other monitors won't blank out.
   display::Screen* screen = display::Screen::GetScreen();
   BOOL hasMultipleMonitors = screen && screen->GetNumDisplays() > 1;
+
+  if (base::FeatureList::IsEnabled(features::kContentFullscreen)) {
+    // Getting the current's window view and its boundaries.
+    NSWindow* window = [self window];
+    WebContents* contents = browser_->tab_strip_model()->GetActiveWebContents();
+    NSView* view = contents->GetNativeView();
+    NSRect windowFrame = window.frame;
+    NSRect viewFrame = [view convertRect:view.bounds toView:nil];
+
+    // Moving the origin from the lower-left corner to the upper-left corner of
+    // the view and cropping out the scrollbar
+    viewFrame.origin.y = NSHeight(windowFrame) - NSMaxY(viewFrame);
+    viewFrame.size.width -= gfx::scrollbar_size();
+
+    // Taking a screenshot of the view and creating the custom view to display
+    CGImageRef windowScreenshot = (CGImageRef)[(id)CGWindowListCreateImage(
+        CGRectZero, kCGWindowListOptionIncludingWindow, [window windowNumber],
+        kCGWindowImageBoundsIgnoreFraming) autorelease];
+    CGImageRef viewScreenshot = (CGImageRef)[(id)CGImageCreateWithImageInRect(
+        windowScreenshot, [window convertRectToBacking:viewFrame]) autorelease];
+    FullscreenPlaceholderView* screenshotView =
+        [[[FullscreenPlaceholderView alloc]
+            initWithFrame:[[self tabContentArea] bounds]
+                    image:viewScreenshot] autorelease];
+    screenshotView.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
+
+    [[self tabContentArea] addSubview:screenshotView];
+  }
+
   if (base::mac::IsAtLeastOS10_10() &&
       !(hasMultipleMonitors && ![NSScreen screensHaveSeparateSpaces])) {
     [self enterAppKitFullscreen];

chrome/browser/ui/cocoa/fullscreen_placeholder_view.h

diff --git a/chrome/browser/ui/cocoa/fullscreen_placeholder_view.h b/chrome/browser/ui/cocoa/fullscreen_placeholder_view.h
new file mode 100644
index 0000000..b6ac530
--- /dev/null
+++ b/chrome/browser/ui/cocoa/fullscreen_placeholder_view.h
@@ -0,0 +1,20 @@
+// Copyright (c) 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_UI_COCOA_FULLSCREEN_PLACEHOLDER_VIEW_H_
+#define CHROME_BROWSER_UI_COCOA_FULLSCREEN_PLACEHOLDER_VIEW_H_
+
+#import <Cocoa/Cocoa.h>
+#import <QuartzCore/CoreImage.h>
+
+@class FullscreenPlaceholderView;
+
+@interface FullscreenPlaceholderView : NSView
+
+// Formats the screenshot displayed on the tab content area when on fullscreen
+- (id)initWithFrame:(NSRect)frameRect image:(CGImageRef)screenshot;
+
+@end  // @interface FullscreenPlaceholderView : NSView
+
+#endif  // CHROME_BROWSER_UI_COCOA_FULLSCREEN_PLACEHOLDER_VIEW_H_

chrome/browser/ui/cocoa/fullscreen_placeholder_view.mm

diff --git a/chrome/browser/ui/cocoa/fullscreen_placeholder_view.mm b/chrome/browser/ui/cocoa/fullscreen_placeholder_view.mm
new file mode 100644
index 0000000..3159e1e
--- /dev/null
+++ b/chrome/browser/ui/cocoa/fullscreen_placeholder_view.mm
@@ -0,0 +1,89 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#import "chrome/browser/ui/cocoa/fullscreen_placeholder_view.h"
+
+namespace {
+
+NSImage* BlurImageWithRadius(CGImageRef image, NSNumber* radius) {
+  CIContext* context = [CIContext contextWithCGContext:nil options:nil];
+  CIImage* inputImage = [[[CIImage alloc] initWithCGImage:image] autorelease];
+
+  CIFilter* clampFilter = [CIFilter filterWithName:@"CIAffineClamp"];
+  [clampFilter setValue:inputImage forKey:kCIInputImageKey];
+  [clampFilter setValue:[NSValue valueWithBytes:&CGAffineTransformIdentity
+                                       objCType:@encode(CGAffineTransform)]
+                 forKey:@"inputTransform"];
+  CIImage* extendedImage = [clampFilter valueForKey:kCIOutputImageKey];
+
+  CIFilter* blurFilter = [CIFilter filterWithName:@"CIGaussianBlur"];
+  [blurFilter setValue:extendedImage forKey:kCIInputImageKey];
+  [blurFilter setValue:radius forKey:@"inputRadius"];
+  CIImage* outputImage = [blurFilter valueForKey:kCIOutputImageKey];
+
+  CGImageRef cgImage =
+      (CGImageRef)[(id)[context createCGImage:outputImage
+                                     fromRect:[inputImage extent]] autorelease];
+  NSImage* resultImage =
+      [[[NSImage alloc] initWithCGImage:cgImage size:CGSizeZero] autorelease];
+  return resultImage;
+}
+}
+
+@implementation FullscreenPlaceholderView {
+  NSTextField* textView_;
+}
+
+- (id)initWithFrame:(NSRect)frameRect image:(CGImageRef)screenshot {
+  if (self = [super initWithFrame:frameRect]) {
+    NSImageView* screenshotView =
+        [[[NSImageView alloc] initWithFrame:self.bounds] autorelease];
+    NSImage* screenshotImage = BlurImageWithRadius(screenshot, @15.0);
+    [screenshotView setImage:screenshotImage];
+
+    textView_ = [[[NSTextField alloc] initWithFrame:frameRect] autorelease];
+    [textView_ setStringValue:@" Click to exit fullscreen "];
+    [textView_ setTextColor:[[NSColor whiteColor] colorWithAlphaComponent:0.6]];
+    [textView_.cell setWraps:NO];
+    [textView_.cell setScrollable:YES];
+    [textView_ setBezeled:NO];
+    [textView_ setEditable:NO];
+    [textView_ setDrawsBackground:NO];
+    [textView_ setWantsLayer:YES];
+    [self resizeLabel];
+
+    NSColor* color = [NSColor colorWithCalibratedWhite:0.3 alpha:0.5];
+    [textView_.layer setBackgroundColor:color.CGColor];
+    [textView_.layer setCornerRadius:12];
+    [screenshotView addSubview:textView_];
+
+    [screenshotView setImageScaling:NSImageScaleAxesIndependently];
+    [screenshotView setAutoresizingMask:NSViewMinYMargin | NSViewMaxXMargin |
+                                        NSViewWidthSizable |
+                                        NSViewHeightSizable];
+    [self addSubview:screenshotView];
+  }
+  return self;
+}
+
+- (void)mouseDown:(NSEvent*)event {
+  // This function handles click events on FullscreenPlaceholderView and will be
+  // used to exit fullscreen
+}
+
+- (void)resizeSubviewsWithOldSize:(CGSize)oldSize {
+  [super resizeSubviewsWithOldSize:oldSize];
+  [self resizeLabel];
+}
+
+- (void)resizeLabel {
+  [textView_ setFont:[NSFont systemFontOfSize:0.023 * (NSWidth(self.frame))]];
+  [textView_ sizeToFit];
+  [textView_
+      setFrameOrigin:NSMakePoint(
+                         NSMidX(self.bounds) - NSMidX(textView_.bounds),
+                         NSMidY(self.bounds) - NSMidY(textView_.bounds))];
+}
+
+@end

chrome/common/extensions/chrome_extension_messages.h

diff --git a/chrome/common/extensions/chrome_extension_messages.h b/chrome/common/extensions/chrome_extension_messages.h
index 5ab455b..216ffaf 100644
--- a/chrome/common/extensions/chrome_extension_messages.h
+++ b/chrome/common/extensions/chrome_extension_messages.h
@@ -75,6 +75,12 @@
 IPC_STRUCT_TRAITS_END()
 
 IPC_STRUCT_BEGIN(ExtensionMsg_AccessibilityEventParams)
+  // ID of the accessibility tree that this event applies to.
+  IPC_STRUCT_MEMBER(int, tree_id)
+
+  // The tree update.
+  IPC_STRUCT_MEMBER(ui::AXTreeUpdate, update)
+
   // Type of event.
   IPC_STRUCT_MEMBER(ui::AXEvent, event_type)
 
@@ -101,16 +107,13 @@
 
 // Forward an accessibility message to an extension process where an
 // extension is using the automation API to listen for accessibility events.
-IPC_MESSAGE_ROUTED4(
-    ExtensionMsg_AccessibilityEvents,
-    int /* ax_tree_id */,
-    ui::AXTreeUpdate /* update */,
-    std::vector<ExtensionMsg_AccessibilityEventParams> /* events */,
-    bool /* is_active_profile */)
+IPC_MESSAGE_ROUTED2(ExtensionMsg_AccessibilityEvent,
+                    ExtensionMsg_AccessibilityEventParams,
+                    bool /* is_active_profile */)
 
 // Forward an accessibility location change message to an extension process
 // where an extension is using the automation API to listen for
 // accessibility events.
-IPC_MESSAGE_ROUTED2(ExtensionMsg_AccessibilityLocationChanges,
-                    int /* ax_tree_id */,
-                    std::vector<ExtensionMsg_AccessibilityLocationChangeParams>)
+IPC_MESSAGE_ROUTED1(ExtensionMsg_AccessibilityLocationChange,
+                    ExtensionMsg_AccessibilityLocationChangeParams)
+

chrome/installer/zucchini/image_utils.h

diff --git a/chrome/installer/zucchini/image_utils.h b/chrome/installer/zucchini/image_utils.h
index dfb55bd1..e9bd79d 100644
--- a/chrome/installer/zucchini/image_utils.h
+++ b/chrome/installer/zucchini/image_utils.h
@@ -85,17 +85,20 @@
   virtual void PutNext(Reference reference) = 0;
 };
 
+// Position of the most significant bit of offset_t.
+constexpr offset_t kIndexMarkBitPosition = sizeof(offset_t) * 8 - 1;
+
 // Helper functions to mark an offset_t, so we can distinguish file offsets from
-// Label indexes. Implementation: Marking is flagged by the most significant bit
+// Label indices. Implementation: Marking is flagged by the most significant bit
 // (MSB).
 constexpr inline bool IsMarked(offset_t value) {
-  return value >> (sizeof(offset_t) * 8 - 1) != 0;
+  return value >> kIndexMarkBitPosition != 0;
 }
 constexpr inline offset_t MarkIndex(offset_t value) {
-  return value | (offset_t(1) << (sizeof(offset_t) * 8 - 1));
+  return value | (offset_t(1) << kIndexMarkBitPosition);
 }
 constexpr inline offset_t UnmarkIndex(offset_t value) {
-  return value & ~(offset_t(1) << (sizeof(offset_t) * 8 - 1));
+  return value & ~(offset_t(1) << kIndexMarkBitPosition);
 }
 
 // An Equivalence is a block of length |length| that approximately match in

chrome/installer/zucchini/label_manager.cc

diff --git a/chrome/installer/zucchini/label_manager.cc b/chrome/installer/zucchini/label_manager.cc
index 590fc16..abbdc0a 100644
--- a/chrome/installer/zucchini/label_manager.cc
+++ b/chrome/installer/zucchini/label_manager.cc
@@ -118,17 +118,16 @@
 void UnorderedLabelManager::InsertNewOffset(offset_t offset) {
   DCHECK(labels_map_.find(offset) == labels_map_.end());
   // Look for unused entry in |labels_|.
-  while (gap_idx_ < labels_.size() && labels_[gap_idx_] != kUnusedIndex)
-    ++gap_idx_;
+  auto pos = std::find(labels_.begin() + gap_idx_, labels_.end(), kUnusedIndex);
   // Either replace the unused entry, or insert at end.
-  if (gap_idx_ < labels_.size()) {
-    labels_map_[offset] = static_cast<offset_t>(gap_idx_);
-    labels_[gap_idx_] = offset;
+  if (pos != labels_.end()) {
+    gap_idx_ = pos - labels_.begin();
+    *pos = offset;
   } else {
-    labels_map_[offset] = static_cast<offset_t>(labels_.size());
+    gap_idx_ = labels_.size();
     labels_.push_back(offset);
   }
-  ++gap_idx_;
+  labels_map_[offset] = static_cast<offset_t>(gap_idx_);
 }
 
 }  // namespace zucchini

chrome/installer/zucchini/label_manager.h

diff --git a/chrome/installer/zucchini/label_manager.h b/chrome/installer/zucchini/label_manager.h
index 9ae466ee9..9b8d0af 100644
--- a/chrome/installer/zucchini/label_manager.h
+++ b/chrome/installer/zucchini/label_manager.h
@@ -10,6 +10,7 @@
 #include <unordered_map>
 #include <vector>
 
+#include "base/logging.h"
 #include "chrome/installer/zucchini/image_utils.h"
 
 namespace zucchini {
@@ -19,14 +20,14 @@
 // - Get the offset of a stored index.
 // - Get the index of a stored offset.
 // - Create new Labels.
-// A LabelManager allows to have a bijection between offsets and indexes.
-// Since not all targets have associated labels from LabelManager, we need mixed
-// representation of targets as offsets or indexes. Hence, indexes are
+// A LabelManager allows to have a bijection between offsets and indices.
+// Since not all targets have associated labels from LabelManager, targets
+// represented both as offset or indices are mixed. Hence, indices are
 // represented as "marked" values (implemented by setting the MSB), and offsets
 // are "unmarked". So when working with stored targets:
 // - IsMarked() distinguishes offsets (false) from indexes (true).
 // - MarkIndex() is used to encode indexes to their stored value.
-// - UnmarkIndex() is used to decode indexes to their actual value.
+// - UnmarkIndex() is used to decode stored indexes to their actual value.
 // - Target offsets are stored verbatim, but they must not be marked. This
 //   affects reference parsing, where we reject all references whose offsets
 //   happen to be marked.
@@ -44,22 +45,22 @@
 
   // Returns whether |offset_or_marked_index| is a valid offset.
   static constexpr bool IsOffset(offset_t offset_or_marked_index) {
-    return offset_or_marked_index != kUnusedIndex &&
-           !IsMarked(offset_or_marked_index);
+    return !IsMarked(offset_or_marked_index);
   }
 
   // Returns whether |offset_or_marked_index| is a valid marked index.
   static constexpr bool IsMarkedIndex(offset_t offset_or_marked_index) {
-    return offset_or_marked_index != kUnusedIndex &&
-           IsMarked(offset_or_marked_index);
+    return IsMarked(offset_or_marked_index) &&
+           offset_or_marked_index != kUnusedIndex;
   }
 
   // Returns whether a given (unmarked) |index| is used by a stored Label.
   bool IsIndexStored(offset_t index) const {
+    DCHECK(!IsMarked(index));
     return index < labels_.size() && labels_[index] != kUnusedIndex;
   }
 
-  // Returns the offset of a given (unmarked) |index| if it is associated to a
+  // Returns the offset of a given (unmarked) |index| if it is associated with a
   // stored Label, or |kUnusedIndex| otherwise.
   offset_t OffsetOfIndex(offset_t index) const {
     return index < labels_.size() ? labels_[index] : kUnusedIndex;

chrome/renderer/content_settings_observer_browsertest.cc

diff --git a/chrome/renderer/content_settings_observer_browsertest.cc b/chrome/renderer/content_settings_observer_browsertest.cc
index 41ca17f..d9021d9 100644
--- a/chrome/renderer/content_settings_observer_browsertest.cc
+++ b/chrome/renderer/content_settings_observer_browsertest.cc
@@ -4,6 +4,9 @@
 
 #include <stddef.h>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "chrome/common/render_messages.h"
@@ -58,6 +61,35 @@
   return RenderFrameObserver::Send(message);
 }
 
+// Evaluates a boolean |predicate| every time a provisional load is committed in
+// the given |frame| while the instance of this class is in scope, and verifies
+// that the result matches the |expectation|.
+class CommitTimeConditionChecker : public content::RenderFrameObserver {
+ public:
+  using Predicate = base::RepeatingCallback<bool()>;
+
+  CommitTimeConditionChecker(content::RenderFrame* frame,
+                             const Predicate& predicate,
+                             bool expectation)
+      : content::RenderFrameObserver(frame),
+        predicate_(predicate),
+        expectation_(expectation) {}
+
+ protected:
+  // RenderFrameObserver:
+  void OnDestruct() override {}
+  void DidCommitProvisionalLoad(bool is_new_navigation,
+                                bool is_same_document_navigation) override {
+    EXPECT_EQ(expectation_, predicate_.Run());
+  }
+
+ private:
+  Predicate predicate_;
+  bool expectation_;
+
+  DISALLOW_COPY_AND_ASSIGN(CommitTimeConditionChecker);
+};
+
 }  // namespace
 
 TEST_F(ChromeRenderViewTest, DidBlockContentType) {
@@ -121,27 +153,27 @@
   base::RunLoop().RunUntilIdle();
   render_thread_->sink().ClearMessages();
 
-  // 3. Reload page.
+  const auto HasSentChromeViewHostMsgContentBlocked =
+      [](content::MockRenderThread* render_thread) {
+        return !!render_thread->sink().GetFirstMessageMatching(
+            ChromeViewHostMsg_ContentBlocked::ID);
+      };
+
+  // 3. Reload page. Verify that the notification that javascript was blocked
+  // has not yet been sent at the time when the navigation commits.
+  CommitTimeConditionChecker checker(
+      view_->GetMainRenderFrame(),
+      base::Bind(HasSentChromeViewHostMsgContentBlocked,
+                 base::Unretained(render_thread_.get())),
+      false);
+
   std::string url_str = "data:text/html;charset=utf-8,";
   url_str.append(kHtml);
   GURL url(url_str);
   Reload(url);
   base::RunLoop().RunUntilIdle();
 
-  // 4. Verify that the notification that javascript was blocked is sent after
-  //    the navigation notification is sent.
-  int navigation_index = -1;
-  int block_index = -1;
-  for (size_t i = 0; i < render_thread_->sink().message_count(); ++i) {
-    const IPC::Message* msg = render_thread_->sink().GetMessageAt(i);
-    if (msg->type() == GetNavigationIPCType())
-      navigation_index = i;
-    if (msg->type() == ChromeViewHostMsg_ContentBlocked::ID)
-      block_index = i;
-  }
-  EXPECT_NE(-1, navigation_index);
-  EXPECT_NE(-1, block_index);
-  EXPECT_LT(navigation_index, block_index);
+  EXPECT_TRUE(HasSentChromeViewHostMsgContentBlocked(render_thread_.get()));
 }
 
 TEST_F(ChromeRenderViewTest, PluginsTemporarilyAllowed) {

chrome/renderer/extensions/automation_internal_custom_bindings.cc

diff --git a/chrome/renderer/extensions/automation_internal_custom_bindings.cc b/chrome/renderer/extensions/automation_internal_custom_bindings.cc
index efacf294..655dfb79 100644
--- a/chrome/renderer/extensions/automation_internal_custom_bindings.cc
+++ b/chrome/renderer/extensions/automation_internal_custom_bindings.cc
@@ -765,14 +765,11 @@
 
 void AutomationInternalCustomBindings::OnMessageReceived(
     const IPC::Message& message) {
-  // http://crbug.com/752788
-  // clang-format off
   IPC_BEGIN_MESSAGE_MAP(AutomationInternalCustomBindings, message)
-    IPC_MESSAGE_HANDLER(ExtensionMsg_AccessibilityEvents, OnAccessibilityEvents)
-    IPC_MESSAGE_HANDLER(ExtensionMsg_AccessibilityLocationChanges,
-                        OnAccessibilityLocationChanges)
+    IPC_MESSAGE_HANDLER(ExtensionMsg_AccessibilityEvent, OnAccessibilityEvent)
+    IPC_MESSAGE_HANDLER(ExtensionMsg_AccessibilityLocationChange,
+                        OnAccessibilityLocationChange)
   IPC_END_MESSAGE_MAP()
-  // clang-format on
 }
 
 TreeCache* AutomationInternalCustomBindings::GetTreeCacheFromTreeID(
@@ -1142,19 +1139,17 @@
 // Handle accessibility events from the browser process.
 //
 
-void AutomationInternalCustomBindings::OnAccessibilityEvents(
-    int ax_tree_id,
-    const ui::AXTreeUpdate& update,
-    const std::vector<ExtensionMsg_AccessibilityEventParams>& events,
+void AutomationInternalCustomBindings::OnAccessibilityEvent(
+    const ExtensionMsg_AccessibilityEventParams& params,
     bool is_active_profile) {
   is_active_profile_ = is_active_profile;
-  int tree_id = ax_tree_id;
+  int tree_id = params.tree_id;
   TreeCache* cache;
   auto iter = tree_id_to_tree_cache_map_.find(tree_id);
   if (iter == tree_id_to_tree_cache_map_.end()) {
     cache = new TreeCache();
     cache->tab_id = -1;
-    cache->tree_id = ax_tree_id;
+    cache->tree_id = params.tree_id;
     cache->parent_node_id_from_parent_tree = -1;
     cache->tree.SetDelegate(this);
     cache->owner = this;
@@ -1166,7 +1161,7 @@
 
   // Update the internal state whether it's the active profile or not.
   deleted_node_ids_.clear();
-  if (!cache->tree.Unserialize(update)) {
+  if (!cache->tree.Unserialize(params.update)) {
     LOG(ERROR) << cache->tree.error();
     base::ListValue args;
     args.AppendInteger(tree_id);
@@ -1183,14 +1178,14 @@
   SendNodesRemovedEvent(&cache->tree, deleted_node_ids_);
   deleted_node_ids_.clear();
 
-  for (auto& event : events) {
+  {
     auto event_params = base::MakeUnique<base::DictionaryValue>();
-    event_params->SetInteger("treeID", ax_tree_id);
-    event_params->SetInteger("targetID", event.id);
-    event_params->SetString("eventType", ToString(event.event_type));
-    event_params->SetString("eventFrom", ToString(event.event_from));
-    event_params->SetInteger("mouseX", event.mouse_location.x());
-    event_params->SetInteger("mouseY", event.mouse_location.y());
+    event_params->SetInteger("treeID", params.tree_id);
+    event_params->SetInteger("targetID", params.id);
+    event_params->SetString("eventType", ToString(params.event_type));
+    event_params->SetString("eventFrom", ToString(params.event_from));
+    event_params->SetInteger("mouseX", params.mouse_location.x());
+    event_params->SetInteger("mouseY", params.mouse_location.y());
     base::ListValue args;
     args.Append(std::move(event_params));
     bindings_system_->DispatchEventInContext(
@@ -1198,21 +1193,19 @@
   }
 }
 
-void AutomationInternalCustomBindings::OnAccessibilityLocationChanges(
-    int tree_id,
-    const std::vector<ExtensionMsg_AccessibilityLocationChangeParams>& params) {
+void AutomationInternalCustomBindings::OnAccessibilityLocationChange(
+    const ExtensionMsg_AccessibilityLocationChangeParams& params) {
+  int tree_id = params.tree_id;
   auto iter = tree_id_to_tree_cache_map_.find(tree_id);
   if (iter == tree_id_to_tree_cache_map_.end())
     return;
   TreeCache* cache = iter->second;
-  for (auto& change : params) {
-    ui::AXNode* node = cache->tree.GetFromId(change.id);
-    if (!node)
-      return;
-    node->SetLocation(change.new_location.offset_container_id,
-                      change.new_location.bounds,
-                      change.new_location.transform.get());
-  }
+  ui::AXNode* node = cache->tree.GetFromId(params.id);
+  if (!node)
+    return;
+  node->SetLocation(params.new_location.offset_container_id,
+                    params.new_location.bounds,
+                    params.new_location.transform.get());
 }
 
 void AutomationInternalCustomBindings::OnNodeDataWillChange(

chrome/renderer/extensions/automation_internal_custom_bindings.h

diff --git a/chrome/renderer/extensions/automation_internal_custom_bindings.h b/chrome/renderer/extensions/automation_internal_custom_bindings.h
index a12cfa8..f33db545 100644
--- a/chrome/renderer/extensions/automation_internal_custom_bindings.h
+++ b/chrome/renderer/extensions/automation_internal_custom_bindings.h
@@ -151,15 +151,10 @@
   //
 
   // Handle accessibility events from the browser process.
-  void OnAccessibilityEvents(
-      int ax_tree_id,
-      const ui::AXTreeUpdate& update,
-      const std::vector<ExtensionMsg_AccessibilityEventParams>& events,
-      bool is_active_profile);
-  void OnAccessibilityLocationChanges(
-      int ax_tree_id,
-      const std::vector<ExtensionMsg_AccessibilityLocationChangeParams>&
-          params);
+  void OnAccessibilityEvent(const ExtensionMsg_AccessibilityEventParams& params,
+                            bool is_active_profile);
+  void OnAccessibilityLocationChange(
+      const ExtensionMsg_AccessibilityLocationChangeParams& params);
 
   void UpdateOverallTreeChangeObserverFilter();
 

chrome/test/data/policy/policy_test_cases.json

diff --git a/chrome/test/data/policy/policy_test_cases.json b/chrome/test/data/policy/policy_test_cases.json
index 39768db..ea97f6bd 100644
--- a/chrome/test/data/policy/policy_test_cases.json
+++ b/chrome/test/data/policy/policy_test_cases.json
@@ -3177,5 +3177,10 @@
   },
 
   "SkipMetadataCheck": {
+  },
+
+  "DeviceOffHours": {
+    "os": ["chromeos"],
+    "test_policy": {"DeviceOffHours": {"interval": [{"start" : {"weekday" : 1, "time": 12840000}, "end": {"weekday" : 1, "time": 21720000}}], "timezone" : "GMT", "ignored_policy": ["allow_new_users", "guest_mode_enabled"]}}
   }
 }

chromecast/media/cma/backend/alsa/stream_mixer_alsa.cc

diff --git a/chromecast/media/cma/backend/alsa/stream_mixer_alsa.cc b/chromecast/media/cma/backend/alsa/stream_mixer_alsa.cc
index 2ee010b..c82a181 100644
--- a/chromecast/media/cma/backend/alsa/stream_mixer_alsa.cc
+++ b/chromecast/media/cma/backend/alsa/stream_mixer_alsa.cc
@@ -125,6 +125,7 @@
 const int kUseDefaultFade = -1;
 const int kMediaDuckFadeMs = 150;
 const int kMediaUnduckFadeMs = 700;
+const int kDefaultFilterFrameAlignment = 256;
 
 int64_t TimespecToMicroseconds(struct timespec time) {
   return static_cast<int64_t>(time.tv_sec) *
@@ -219,7 +220,8 @@
       state_(kStateUninitialized),
       retry_write_frames_timer_(new base::Timer(false, false)),
       check_close_timeout_(kDefaultCheckCloseTimeoutMs),
-      check_close_timer_(new base::Timer(false, false)) {
+      check_close_timer_(new base::Timer(false, false)),
+      filter_frame_alignment_(kDefaultFilterFrameAlignment) {
   if (single_threaded_for_test_) {
     mixer_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   } else {
@@ -261,6 +263,10 @@
 
   CreatePostProcessors(&pipeline_parser);
 
+  // TODO(jyw): command line flag for filter frame alignment.
+  DCHECK_EQ(filter_frame_alignment_ & (filter_frame_alignment_ - 1), 0)
+      << "Alignment must be a power of 2.";
+
   // TODO(bshaya): Add support for final mix AudioPostProcessor.
   DefineAlsaParameters();
 }
@@ -853,13 +859,14 @@
   const int min_frames_in_buffer =
       output_samples_per_second_ * kMinBufferedDataMs / 1000;
   int chunk_size =
-      output_samples_per_second_ * kMaxAudioWriteTimeMilliseconds / 1000;
+      (output_samples_per_second_ * kMaxAudioWriteTimeMilliseconds / 1000) &
+      ~(filter_frame_alignment_ - 1);
   bool is_silence = true;
   for (auto&& filter_group : filter_groups_) {
     filter_group->ClearActiveInputs();
   }
   for (auto&& input : inputs_) {
-    int read_size = input->MaxReadSize();
+    int read_size = input->MaxReadSize() & ~(filter_frame_alignment_ - 1);
     if (read_size > 0) {
       DCHECK(input->filter_group());
       input->filter_group()->AddActiveInput(input.get());
@@ -893,9 +900,10 @@
 
   if (is_silence) {
     // No inputs have any data to provide. Push silence to prevent underrun.
-    chunk_size = kPreventUnderrunChunkSize;
+    chunk_size = std::max(kPreventUnderrunChunkSize, filter_frame_alignment_);
   }
 
+  DCHECK_EQ(chunk_size % filter_frame_alignment_, 0);
   // Recursively mix and filter each group.
   linearize_filter_->MixAndFilter(chunk_size);
 
@@ -1093,5 +1101,15 @@
   }
 }
 
+void StreamMixerAlsa::SetFilterFrameAlignmentForTest(
+    int filter_frame_alignment) {
+  RUN_ON_MIXER_THREAD(&StreamMixerAlsa::SetFilterFrameAlignmentForTest,
+                      filter_frame_alignment);
+  CHECK((filter_frame_alignment & (filter_frame_alignment - 1)) == 0)
+      << "Frame alignment ( " << filter_frame_alignment
+      << ") is not a power of two";
+  filter_frame_alignment_ = filter_frame_alignment;
+}
+
 }  // namespace media
 }  // namespace chromecast

chromecast/media/cma/backend/alsa/stream_mixer_alsa.h

diff --git a/chromecast/media/cma/backend/alsa/stream_mixer_alsa.h b/chromecast/media/cma/backend/alsa/stream_mixer_alsa.h
index 654bcde..a2a3714a 100644
--- a/chromecast/media/cma/backend/alsa/stream_mixer_alsa.h
+++ b/chromecast/media/cma/backend/alsa/stream_mixer_alsa.h
@@ -165,6 +165,8 @@
     return mixer_task_runner_;
   }
 
+  int filter_frame_alignment() const { return filter_frame_alignment_; }
+
   // Adds an input to the mixer. The input will live at least until
   // RemoveInput(input) is called. Can be called on any thread.
   void AddInput(std::unique_ptr<InputQueue> input);
@@ -200,6 +202,10 @@
   void SetPostProcessorConfig(const std::string& name,
                               const std::string& config);
 
+  // Sets filter data alignment, required by some processors.
+  // Must be called before audio playback starts.
+  void SetFilterFrameAlignmentForTest(int filter_frame_alignment);
+
  protected:
   StreamMixerAlsa();
   virtual ~StreamMixerAlsa();
@@ -295,6 +301,11 @@
   FilterGroup* linearize_filter_;
   std::vector<uint8_t> interleaved_;
 
+  // Force data to be filtered in multiples of |filter_frame_alignment_| frames.
+  // Must be a multiple of 4 for some NEON implementations. Some
+  // AudioPostProcessors require stricter alignment conditions.
+  int filter_frame_alignment_;
+
   std::vector<CastMediaShlib::LoopbackAudioObserver*> loopback_observers_;
 
   std::map<AudioContentType, VolumeInfo> volume_info_;

chromecast/media/cma/backend/alsa/stream_mixer_alsa_input_impl.cc

diff --git a/chromecast/media/cma/backend/alsa/stream_mixer_alsa_input_impl.cc b/chromecast/media/cma/backend/alsa/stream_mixer_alsa_input_impl.cc
index 62652bff..34d95f26 100644
--- a/chromecast/media/cma/backend/alsa/stream_mixer_alsa_input_impl.cc
+++ b/chromecast/media/cma/backend/alsa/stream_mixer_alsa_input_impl.cc
@@ -48,7 +48,7 @@
 
 const int kNumOutputChannels = 2;
 const int64_t kMaxInputQueueUs = 90000;
-const int64_t kFadeMs = 15;
+const int64_t kMinFadeMs = 15;
 // Number of samples to report as readable when paused. When paused, the mixer
 // will still pull this many frames each time it tries to write frames, but we
 // fill the frames with silence.
@@ -69,6 +69,10 @@
   }
 }
 
+int RoundUpMultiple(int value, int multiple) {
+  return multiple * ((value + (multiple - 1)) / multiple);
+}
+
 }  // namespace
 
 StreamMixerAlsaInputImpl::StreamMixerAlsaInputImpl(
@@ -186,14 +190,15 @@
     base::AutoLock lock(queue_lock_);
     if (state_ == kStateGotEos) {
       fade_out_frames_total_ =
-          queued_frames_including_resampler_ / resample_ratio_;
-      fade_frames_remaining_ =
-          queued_frames_including_resampler_ / resample_ratio_;
+          RoundUpMultiple(queued_frames_including_resampler_ / resample_ratio_,
+                          mixer_->filter_frame_alignment());
+      fade_frames_remaining_ = fade_out_frames_total_;
     } else if (state_ == kStateNormalPlayback) {
-      fade_out_frames_total_ =
-          std::min(static_cast<int>(queued_frames_including_resampler_ /
-                                    resample_ratio_),
-                   NormalFadeFrames());
+      fade_out_frames_total_ = std::min(
+          RoundUpMultiple(static_cast<int>(queued_frames_including_resampler_ /
+                                           resample_ratio_),
+                          mixer_->filter_frame_alignment()),
+          NormalFadeFrames());
       fade_frames_remaining_ = fade_out_frames_total_;
     }
   }
@@ -335,10 +340,13 @@
   int queued_frames;
   {
     base::AutoLock lock(queue_lock_);
-    if (state_ == kStateGotEos)
-      return std::max(static_cast<int>(queued_frames_including_resampler_ /
-                                       resample_ratio_),
-                      kDefaultReadSize);
+    if (state_ == kStateGotEos) {
+      return RoundUpMultiple(
+          std::max(static_cast<int>(queued_frames_including_resampler_ /
+                                    resample_ratio_),
+                   kDefaultReadSize),
+          mixer_->filter_frame_alignment());
+    }
     queued_frames = queued_frames_;
   }
 
@@ -350,8 +358,9 @@
     available_frames = queued_frames;
   }
 
-  if (state_ == kStateFadingOut)
+  if (state_ == kStateFadingOut) {
     return std::min(available_frames, fade_frames_remaining_);
+  }
   return std::max(0, available_frames - NormalFadeFrames());
 }
 
@@ -454,15 +463,17 @@
 
 int StreamMixerAlsaInputImpl::NormalFadeFrames() {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
-  int frames = (mixer_->output_samples_per_second() * kFadeMs /
+  int frames = (mixer_->output_samples_per_second() * kMinFadeMs /
                 base::Time::kMillisecondsPerSecond) -
                1;
-  return std::max(frames, 0);
+  return frames <= 0
+             ? 0
+             : RoundUpMultiple(frames, mixer_->filter_frame_alignment());
 }
 
 void StreamMixerAlsaInputImpl::FadeIn(::media::AudioBus* dest, int frames) {
   DCHECK(mixer_task_runner_->BelongsToCurrentThread());
-  float fade_in_frames = mixer_->output_samples_per_second() * kFadeMs /
+  float fade_in_frames = mixer_->output_samples_per_second() * kMinFadeMs /
                          base::Time::kMillisecondsPerSecond;
   for (int f = 0; f < frames && fade_frames_remaining_; ++f) {
     float fade_multiplier = 1.0 - fade_frames_remaining_ / fade_in_frames;

chromecast/media/cma/backend/alsa/stream_mixer_alsa_unittest.cc

diff --git a/chromecast/media/cma/backend/alsa/stream_mixer_alsa_unittest.cc b/chromecast/media/cma/backend/alsa/stream_mixer_alsa_unittest.cc
index 45983232..fe2d256 100644
--- a/chromecast/media/cma/backend/alsa/stream_mixer_alsa_unittest.cc
+++ b/chromecast/media/cma/backend/alsa/stream_mixer_alsa_unittest.cc
@@ -549,6 +549,7 @@
   }
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
+  mixer->SetFilterFrameAlignmentForTest(1);
   for (size_t i = 0; i < inputs.size(); ++i) {
     EXPECT_CALL(*inputs[i], Initialize(_)).Times(1);
     mixer->AddInput(base::WrapUnique(inputs[i]));
@@ -606,6 +607,7 @@
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
   EXPECT_CALL(*input, Initialize(_)).Times(1);
+  mixer->SetFilterFrameAlignmentForTest(4);
   mixer->AddInput(base::WrapUnique(input));
   EXPECT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
 
@@ -636,6 +638,7 @@
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
   EXPECT_CALL(*input, Initialize(_)).Times(1);
+  mixer->SetFilterFrameAlignmentForTest(4);
   mixer->AddInput(base::WrapUnique(input));
   EXPECT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
 
@@ -673,6 +676,7 @@
   }
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
+  mixer->SetFilterFrameAlignmentForTest(4);
   for (size_t i = 0; i < inputs.size(); ++i) {
     EXPECT_CALL(*inputs[i], Initialize(_)).Times(1);
     mixer->AddInput(base::WrapUnique(inputs[i]));
@@ -714,6 +718,7 @@
   inputs.back()->SetPaused(false);
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
+  mixer->SetFilterFrameAlignmentForTest(4);
   for (size_t i = 0; i < inputs.size(); ++i) {
     EXPECT_CALL(*inputs[i], Initialize(_)).Times(1);
     mixer->AddInput(base::WrapUnique(inputs[i]));
@@ -753,6 +758,7 @@
   }
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
+  mixer->SetFilterFrameAlignmentForTest(4);
   for (size_t i = 0; i < inputs.size(); ++i) {
     EXPECT_CALL(*inputs[i], Initialize(_)).Times(1);
     mixer->AddInput(base::WrapUnique(inputs[i]));
@@ -765,7 +771,7 @@
   // ::media::AudioBus instances, rather than wrapping statically declared float
   // arrays. The latter method is brittle, as ::media::AudioBus requires 16-bit
   // alignment for internal data.
-  const int kNumFrames = 3;
+  const int kNumFrames = 4;
 
   const int32_t kMaxSample = std::numeric_limits<int32_t>::max();
   const int32_t kMinSample = std::numeric_limits<int32_t>::min();
@@ -821,16 +827,17 @@
   input->SetPaused(false);
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
+  mixer->SetFilterFrameAlignmentForTest(4);
   EXPECT_CALL(*input, Initialize(_)).Times(1);
   mixer->AddInput(base::WrapUnique(input));
   EXPECT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
 
   // The input stream will provide buffers of several different lengths.
-  input->SetMaxReadSize(7);
-  EXPECT_CALL(*input, GetResampledData(_, 7));
-  EXPECT_CALL(*input, VolumeScaleAccumulate(_, _, 7, _)).Times(kNumChannels);
+  input->SetMaxReadSize(8);
+  EXPECT_CALL(*input, GetResampledData(_, 8));
+  EXPECT_CALL(*input, VolumeScaleAccumulate(_, _, 8, _)).Times(kNumChannels);
   EXPECT_CALL(*input, AfterWriteFrames(_));
-  EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, 7)).Times(1);
+  EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, 8)).Times(1);
   mixer->WriteFramesForTest();
 
   input->SetMaxReadSize(100);
@@ -896,6 +903,7 @@
   }
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
+  mixer->SetFilterFrameAlignmentForTest(4);
   for (size_t i = 0; i < inputs.size(); ++i) {
     EXPECT_CALL(*inputs[i], Initialize(_)).Times(1);
     mixer->AddInput(base::WrapUnique(inputs[i]));
@@ -989,13 +997,14 @@
   std::transform(delays.begin(), delays.end(), delays.begin(),
                  &FramesToDelayUs);
 
-  const int kNumFrames = 10;
+  const int kNumFrames = 12;
   for (auto* input : inputs) {
     input->SetMaxReadSize(kNumFrames);
     input->SetPaused(false);
   }
 
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
+  mixer->SetFilterFrameAlignmentForTest(4);
   for (size_t i = 0; i < inputs.size(); ++i) {
     EXPECT_CALL(*inputs[i], Initialize(_)).Times(1);
     mixer->AddInput(base::WrapUnique(inputs[i]));
@@ -1035,7 +1044,7 @@
   // Delay should be based on default processor
   int64_t delay = FramesToDelayUs(
       kDefaultProcessorDelay + kLinearizeProcessorDelay + kMixProcessorDelay);
-  const int kNumFrames = 10;
+  const int kNumFrames = 12;
   input->SetMaxReadSize(kNumFrames);
   input->SetPaused(false);
 
@@ -1062,6 +1071,69 @@
   mixer->WriteFramesForTest();
 }
 
+TEST_F(StreamMixerAlsaTest, OneStreamTruncatedProperlyFrameAlignment4) {
+  auto* input = new testing::StrictMock<MockInputQueue>(kTestSamplesPerSecond);
+  input->SetPaused(false);
+
+  StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
+  mixer->SetFilterFrameAlignmentForTest(4);
+  EXPECT_CALL(*input, Initialize(_)).Times(1);
+  mixer->AddInput(base::WrapUnique(input));
+  EXPECT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
+
+  // Precalculated output chunk sizes for given input chunk sizes assuming
+  // 4 frame alignment.
+  int in_out[6][2] = {{4, 4}, {7, 4}, {8, 8}, {9, 8}, {880, 880}, {882, 880}};
+
+  for (int i = 0; i < 6; ++i) {
+    int readSize = in_out[i][0];
+    int expectedSize = in_out[i][1];
+    input->SetMaxReadSize(readSize);
+    EXPECT_CALL(*input, GetResampledData(_, expectedSize));
+    EXPECT_CALL(*input, VolumeScaleAccumulate(_, _, expectedSize, _))
+        .Times(kNumChannels);
+    EXPECT_CALL(*input, AfterWriteFrames(_));
+    EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, expectedSize)).Times(1);
+    mixer->WriteFramesForTest();
+  }
+}
+
+TEST_F(StreamMixerAlsaTest, OneStreamTruncatedProperlyFrameAlignment256) {
+  auto* input = new testing::StrictMock<MockInputQueue>(kTestSamplesPerSecond);
+  input->SetPaused(false);
+
+  StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
+  mixer->SetFilterFrameAlignmentForTest(256);
+  EXPECT_CALL(*input, Initialize(_)).Times(1);
+  mixer->AddInput(base::WrapUnique(input));
+  EXPECT_EQ(StreamMixerAlsa::kStateNormalPlayback, mixer->state());
+
+  // Precalculated output chunk sizes for given input chunk sizes assuming
+  // 256 frame alignment.
+  int in_out[4][2] = {{256, 256}, {511, 256}, {512, 512}, {513, 512}};
+
+  for (int i = 0; i < 4; ++i) {
+    int readSize = in_out[i][0];
+    int expectedSize = in_out[i][1];
+    input->SetMaxReadSize(readSize);
+    EXPECT_CALL(*input, GetResampledData(_, expectedSize));
+    EXPECT_CALL(*input, VolumeScaleAccumulate(_, _, expectedSize, _))
+        .Times(kNumChannels);
+    EXPECT_CALL(*input, AfterWriteFrames(_));
+    EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, expectedSize)).Times(1);
+    mixer->WriteFramesForTest();
+  }
+
+  // Do nothing if there isn't enough data.
+  input->SetMaxReadSize(123);  // 0 < 123 < filter frame alignment
+  EXPECT_CALL(*input, GetResampledData(_, _)).Times(0);
+  EXPECT_CALL(*input, VolumeScaleAccumulate(_, _, _, _)).Times(0);
+  EXPECT_CALL(*input, AfterWriteFrames(_)).Times(0);
+
+  EXPECT_CALL(*mock_alsa(), PcmWritei(_, _, _)).Times(0);
+  mixer->WriteFramesForTest();
+}
+
 TEST_F(StreamMixerAlsaTest, PostProcessorRingingWithoutInput) {
   const char kTestPipelineJson[] = R"json(
 {
@@ -1092,6 +1164,7 @@
   StreamMixerAlsa* mixer = StreamMixerAlsa::Get();
   std::string test_pipeline_json = base::StringPrintf(
       kTestPipelineJson, kDelayModuleSolib, kDelayModuleSolib);
+  mixer->SetFilterFrameAlignmentForTest(4);
   mixer->ResetPostProcessorsForTest(test_pipeline_json);
   mixer->AddInput(base::WrapUnique(input));
 

components/arc/bluetooth/arc_bluetooth_bridge.cc

diff --git a/components/arc/bluetooth/arc_bluetooth_bridge.cc b/components/arc/bluetooth/arc_bluetooth_bridge.cc
index e58f78ac..682694b 100644
--- a/components/arc/bluetooth/arc_bluetooth_bridge.cc
+++ b/components/arc/bluetooth/arc_bluetooth_bridge.cc
@@ -2043,10 +2043,13 @@
     ArcBluetoothBridge::AdapterPowerState powered,
     const EnableAdapterCallback& callback) {
   remote_power_changes_.push(powered);
+
+  bool turn_on = (powered == AdapterPowerState::TURN_ON);
   bluetooth_adapter_->SetPowered(
-      powered == AdapterPowerState::TURN_ON,
-      base::Bind(&ArcBluetoothBridge::OnPoweredOff, weak_factory_.GetWeakPtr(),
-                 callback),
+      turn_on,
+      base::Bind(turn_on ? &ArcBluetoothBridge::OnPoweredOn
+                         : &ArcBluetoothBridge::OnPoweredOff,
+                 weak_factory_.GetWeakPtr(), callback),
       base::Bind(&ArcBluetoothBridge::OnPoweredError,
                  weak_factory_.GetWeakPtr(), callback));
 }

components/background_task_scheduler/android/java/src/org/chromium/components/background_task_scheduler/BackgroundTaskSchedulerGcmNetworkManager.java

diff --git a/components/background_task_scheduler/android/java/src/org/chromium/components/background_task_scheduler/BackgroundTaskSchedulerGcmNetworkManager.java b/components/background_task_scheduler/android/java/src/org/chromium/components/background_task_scheduler/BackgroundTaskSchedulerGcmNetworkManager.java
index bcc46bc..41f27d8f 100644
--- a/components/background_task_scheduler/android/java/src/org/chromium/components/background_task_scheduler/BackgroundTaskSchedulerGcmNetworkManager.java
+++ b/components/background_task_scheduler/android/java/src/org/chromium/components/background_task_scheduler/BackgroundTaskSchedulerGcmNetworkManager.java
@@ -151,7 +151,13 @@
 
         Task task = createTaskFromTaskInfo(taskInfo);
 
-        gcmNetworkManager.schedule(task);
+        try {
+            gcmNetworkManager.schedule(task);
+        } catch (IllegalArgumentException e) {
+            Log.e(TAG, "GcmNetworkManager failed to schedule task.");
+            return false;
+        }
+
         return true;
     }
 
@@ -165,7 +171,12 @@
             return;
         }
 
-        gcmNetworkManager.cancelTask(taskIdToTaskTag(taskId), BackgroundTaskGcmTaskService.class);
+        try {
+            gcmNetworkManager.cancelTask(
+                    taskIdToTaskTag(taskId), BackgroundTaskGcmTaskService.class);
+        } catch (IllegalArgumentException e) {
+            Log.e(TAG, "GcmNetworkManager failed to cancel task.");
+        }
     }
 
     private GcmNetworkManager getGcmNetworkManager(Context context) {

components/exo/wayland/BUILD.gn

diff --git a/components/exo/wayland/BUILD.gn b/components/exo/wayland/BUILD.gn
index a2c21cfb..f1bae38 100644
--- a/components/exo/wayland/BUILD.gn
+++ b/components/exo/wayland/BUILD.gn
@@ -91,6 +91,7 @@
     "//third_party/wayland:wayland_client",
   ]
 }
+
 source_set("client_lib") {
   sources = [
     "clients/client_base.cc",
@@ -174,6 +175,33 @@
   }
 }
 
+executable("wayland_subsurface_client") {
+  sources = [
+    "clients/subsurface.cc",
+  ]
+
+  deps = [
+    ":client_lib",
+    "//base",
+    "//build/config:exe_and_shlib_deps",
+    "//skia",
+    "//third_party/wayland:wayland_client",
+    "//third_party/wayland-protocols:linux_dmabuf_protocol",
+    "//third_party/wayland-protocols:presentation_time_protocol",
+    "//ui/gfx/geometry",
+    "//ui/gl",
+  ]
+
+  if (ozone_platform_gbm) {
+    configs += [
+      ":libdrm",
+      "//ui/gl:gl_config",
+    ]
+    defines = [ "OZONE_PLATFORM_GBM" ]
+    deps += [ "//third_party/minigbm" ]
+  }
+}
+
 if (ozone_platform_gbm) {
   executable("wayland_yuv_client") {
     sources = [

components/exo/wayland/clients/client_base.cc

diff --git a/components/exo/wayland/clients/client_base.cc b/components/exo/wayland/clients/client_base.cc
index ddc142a..b4830f0 100644
--- a/components/exo/wayland/clients/client_base.cc
+++ b/components/exo/wayland/clients/client_base.cc
@@ -101,6 +101,9 @@
   } else if (strcmp(interface, "zwp_linux_dmabuf_v1") == 0) {
     globals->linux_dmabuf.reset(static_cast<zwp_linux_dmabuf_v1*>(
         wl_registry_bind(registry, id, &zwp_linux_dmabuf_v1_interface, 1)));
+  } else if (strcmp(interface, "wl_subcompositor") == 0) {
+    globals->subcompositor.reset(static_cast<wl_subcompositor*>(
+        wl_registry_bind(registry, id, &wl_subcompositor_interface, 1)));
   }
 }
 
@@ -130,11 +133,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 // ClientBase::InitParams, public:
 
-ClientBase::InitParams::InitParams() {
-#if defined(OZONE_PLATFORM_GBM)
-  drm_format = DRM_FORMAT_ABGR8888;
-#endif
-}
+ClientBase::InitParams::InitParams() {}
 
 ClientBase::InitParams::~InitParams() {}
 
@@ -183,8 +182,7 @@
 // ClientBase, public:
 
 bool ClientBase::Init(const InitParams& params) {
-  width_ = params.width;
-  height_ = params.height;
+  size_.SetSize(params.width, params.height);
   scale_ = params.scale;
   fullscreen_ = params.fullscreen;
   transparent_background_ = params.transparent_background;
@@ -293,7 +291,7 @@
   }
 #endif
   for (size_t i = 0; i < params.num_buffers; ++i) {
-    auto buffer = CreateBuffer(params.drm_format);
+    auto buffer = CreateBuffer(size_);
     if (!buffer) {
       LOG(ERROR) << "Failed to create buffer";
       return false;
@@ -308,9 +306,6 @@
       LOG(ERROR) << "buffer handle uninitialized.";
       return false;
     }
-
-    wl_buffer_add_listener(buffers_[i]->buffer.get(), &g_buffer_listener,
-                           buffers_[i].get());
   }
 
   surface_.reset(static_cast<wl_surface*>(
@@ -328,7 +323,7 @@
       return false;
     }
 
-    wl_region_add(opaque_region.get(), 0, 0, width_, height_);
+    wl_region_add(opaque_region.get(), 0, 0, size_.width(), size_.height());
     wl_surface_set_opaque_region(surface_.get(), opaque_region.get());
   }
   std::unique_ptr<wl_shell_surface> shell_surface(
@@ -363,11 +358,48 @@
 // ClientBase, private:
 
 std::unique_ptr<ClientBase::Buffer> ClientBase::CreateBuffer(
+    const gfx::Size& size) {
+  std::unique_ptr<Buffer> buffer = CreateDRMBuffer(size, DRM_FORMAT_ABGR8888);
+  if (buffer)
+    return buffer;
+
+  buffer = base::MakeUnique<Buffer>();
+
+  size_t stride = size.width() * kBytesPerPixel;
+  buffer->shared_memory.reset(new base::SharedMemory());
+  buffer->shared_memory->CreateAndMapAnonymous(stride * size.height());
+  buffer->shm_pool.reset(wl_shm_create_pool(
+      globals_.shm.get(), buffer->shared_memory->handle().GetHandle(),
+      buffer->shared_memory->requested_size()));
+
+  buffer->buffer.reset(static_cast<wl_buffer*>(
+      wl_shm_pool_create_buffer(buffer->shm_pool.get(), 0, size.width(),
+                                size.height(), stride, kShmFormat)));
+  if (!buffer->buffer) {
+    LOG(ERROR) << "Can't create buffer";
+    return nullptr;
+  }
+
+  wl_buffer_add_listener(buffer->buffer.get(), &g_buffer_listener,
+                         buffer.get());
+
+  buffer->sk_surface = SkSurface::MakeRasterDirect(
+      SkImageInfo::Make(size.width(), size.height(), kColorType,
+                        kOpaque_SkAlphaType),
+      static_cast<uint8_t*>(buffer->shared_memory->memory()), stride);
+  DCHECK(buffer->sk_surface);
+  return buffer;
+}
+
+std::unique_ptr<ClientBase::Buffer> ClientBase::CreateDRMBuffer(
+    const gfx::Size& size,
     int32_t drm_format) {
-  std::unique_ptr<Buffer> buffer(new Buffer());
+  std::unique_ptr<Buffer> buffer;
 #if defined(OZONE_PLATFORM_GBM)
   if (device_) {
-    buffer->bo.reset(gbm_bo_create(device_.get(), width_, height_, drm_format,
+    buffer = base::MakeUnique<Buffer>();
+    buffer->bo.reset(gbm_bo_create(device_.get(), size.width(), size.height(),
+                                   drm_format,
                                    GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING));
     if (!buffer->bo) {
       LOG(ERROR) << "Can't create gbm buffer";
@@ -385,7 +417,7 @@
                                      stride, 0, 0);
     }
     buffer->buffer.reset(zwp_linux_buffer_params_v1_create_immed(
-        buffer->params.get(), width_, height_, drm_format, 0));
+        buffer->params.get(), size.width(), size.height(), drm_format, 0));
 
     if (gbm_bo_get_num_planes(buffer->bo.get()) != 1)
       return buffer;
@@ -393,9 +425,9 @@
     EGLint khr_image_attrs[] = {EGL_DMA_BUF_PLANE0_FD_EXT,
                                 fd.get(),
                                 EGL_WIDTH,
-                                width_,
+                                size.width(),
                                 EGL_HEIGHT,
-                                height_,
+                                size.height(),
                                 EGL_LINUX_DRM_FOURCC_EXT,
                                 drm_format,
                                 EGL_DMA_BUF_PLANE0_PITCH_EXT,
@@ -419,34 +451,14 @@
     GrGLTextureInfo texture_info;
     texture_info.fID = buffer->texture->get();
     texture_info.fTarget = GL_TEXTURE_2D;
-    GrBackendTexture backend_texture(width_, height_, kGrPixelConfig,
-                                     texture_info);
+    GrBackendTexture backend_texture(size.width(), size.height(),
+                                     kGrPixelConfig, texture_info);
     buffer->sk_surface = SkSurface::MakeFromBackendTextureAsRenderTarget(
         gr_context_.get(), backend_texture, kTopLeft_GrSurfaceOrigin,
         /* sampleCnt */ 0, /* colorSpace */ nullptr, /* props */ nullptr);
     DCHECK(buffer->sk_surface);
-    return buffer;
   }
 #endif
-
-  size_t stride = width_ * kBytesPerPixel;
-  buffer->shared_memory.reset(new base::SharedMemory());
-  buffer->shared_memory->CreateAndMapAnonymous(stride * height_);
-  buffer->shm_pool.reset(wl_shm_create_pool(
-      globals_.shm.get(), buffer->shared_memory->handle().GetHandle(),
-      buffer->shared_memory->requested_size()));
-
-  buffer->buffer.reset(static_cast<wl_buffer*>(wl_shm_pool_create_buffer(
-      buffer->shm_pool.get(), 0, width_, height_, stride, kShmFormat)));
-  if (!buffer->buffer) {
-    LOG(ERROR) << "Can't create buffer";
-    return nullptr;
-  }
-
-  buffer->sk_surface = SkSurface::MakeRasterDirect(
-      SkImageInfo::Make(width_, height_, kColorType, kOpaque_SkAlphaType),
-      static_cast<uint8_t*>(buffer->shared_memory->memory()), stride);
-  DCHECK(buffer->sk_surface);
   return buffer;
 }
 

components/exo/wayland/clients/client_base.h

diff --git a/components/exo/wayland/clients/client_base.h b/components/exo/wayland/clients/client_base.h
index 2fef99a..b2d5c9a 100644
--- a/components/exo/wayland/clients/client_base.h
+++ b/components/exo/wayland/clients/client_base.h
@@ -13,6 +13,7 @@
 #include "components/exo/wayland/clients/client_helper.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
+#include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/scoped_make_current.h"
@@ -43,7 +44,6 @@
     bool transparent_background = false;
     bool use_drm = false;
     std::string use_drm_value;
-    int32_t drm_format = 0;
   };
 
   struct Globals {
@@ -56,6 +56,7 @@
     std::unique_ptr<zwp_linux_dmabuf_v1> linux_dmabuf;
     std::unique_ptr<wl_shell> shell;
     std::unique_ptr<wl_seat> seat;
+    std::unique_ptr<wl_subcompositor> subcompositor;
   };
 
   struct Buffer {
@@ -81,9 +82,11 @@
  protected:
   ClientBase();
   virtual ~ClientBase();
+  std::unique_ptr<Buffer> CreateBuffer(const gfx::Size& size);
+  std::unique_ptr<Buffer> CreateDRMBuffer(const gfx::Size& size,
+                                          int32_t drm_format);
 
-  size_t width_ = 256;
-  size_t height_ = 256;
+  gfx::Size size_ = gfx::Size(256, 256);
   int scale_ = 1;
   bool fullscreen_ = false;
   bool transparent_background_ = false;
@@ -104,9 +107,6 @@
   std::vector<std::unique_ptr<Buffer>> buffers_;
   sk_sp<GrContext> gr_context_;
 
- private:
-  std::unique_ptr<Buffer> CreateBuffer(int32_t drm_format);
-
   DISALLOW_COPY_AND_ASSIGN(ClientBase);
 };
 

components/exo/wayland/clients/client_helper.cc

diff --git a/components/exo/wayland/clients/client_helper.cc b/components/exo/wayland/clients/client_helper.cc
index 51ccd77..b7c859d 100644
--- a/components/exo/wayland/clients/client_helper.cc
+++ b/components/exo/wayland/clients/client_helper.cc
@@ -25,19 +25,21 @@
   }                                                          \
   }
 
-DEFAULT_DELETER(wl_display, wl_display_disconnect)
-DEFAULT_DELETER(wl_compositor, wl_compositor_destroy)
-DEFAULT_DELETER(wl_shm, wl_shm_destroy)
-DEFAULT_DELETER(wl_shm_pool, wl_shm_pool_destroy)
 DEFAULT_DELETER(wl_buffer, wl_buffer_destroy)
-DEFAULT_DELETER(wl_surface, wl_surface_destroy)
+DEFAULT_DELETER(wl_callback, wl_callback_destroy)
+DEFAULT_DELETER(wl_compositor, wl_compositor_destroy)
+DEFAULT_DELETER(wl_display, wl_display_disconnect)
+DEFAULT_DELETER(wl_pointer, wl_pointer_destroy)
 DEFAULT_DELETER(wl_region, wl_region_destroy)
+DEFAULT_DELETER(wl_seat, wl_seat_destroy)
 DEFAULT_DELETER(wl_shell, wl_shell_destroy)
 DEFAULT_DELETER(wl_shell_surface, wl_shell_surface_destroy)
-DEFAULT_DELETER(wl_seat, wl_seat_destroy)
-DEFAULT_DELETER(wl_pointer, wl_pointer_destroy)
+DEFAULT_DELETER(wl_shm, wl_shm_destroy)
+DEFAULT_DELETER(wl_shm_pool, wl_shm_pool_destroy)
+DEFAULT_DELETER(wl_subcompositor, wl_subcompositor_destroy)
+DEFAULT_DELETER(wl_subsurface, wl_subsurface_destroy)
+DEFAULT_DELETER(wl_surface, wl_surface_destroy)
 DEFAULT_DELETER(wl_touch, wl_touch_destroy)
-DEFAULT_DELETER(wl_callback, wl_callback_destroy)
 DEFAULT_DELETER(wp_presentation, wp_presentation_destroy)
 DEFAULT_DELETER(struct wp_presentation_feedback,
                 wp_presentation_feedback_destroy)
@@ -45,8 +47,8 @@
 DEFAULT_DELETER(zwp_linux_dmabuf_v1, zwp_linux_dmabuf_v1_destroy)
 
 #if defined(OZONE_PLATFORM_GBM)
-DEFAULT_DELETER(gbm_device, gbm_device_destroy)
 DEFAULT_DELETER(gbm_bo, gbm_bo_destroy)
+DEFAULT_DELETER(gbm_device, gbm_device_destroy)
 #endif
 
 namespace exo {

components/exo/wayland/clients/client_helper.h

diff --git a/components/exo/wayland/clients/client_helper.h b/components/exo/wayland/clients/client_helper.h
index c9a5952..cbb7039 100644
--- a/components/exo/wayland/clients/client_helper.h
+++ b/components/exo/wayland/clients/client_helper.h
@@ -27,27 +27,29 @@
   };                                    \
   }
 
-DEFAULT_DELETER_FDECL(wl_display)
-DEFAULT_DELETER_FDECL(wl_compositor)
-DEFAULT_DELETER_FDECL(wl_shm)
-DEFAULT_DELETER_FDECL(wl_shm_pool)
 DEFAULT_DELETER_FDECL(wl_buffer)
-DEFAULT_DELETER_FDECL(wl_surface)
+DEFAULT_DELETER_FDECL(wl_callback)
+DEFAULT_DELETER_FDECL(wl_compositor)
+DEFAULT_DELETER_FDECL(wl_display)
+DEFAULT_DELETER_FDECL(wl_pointer)
 DEFAULT_DELETER_FDECL(wl_region)
+DEFAULT_DELETER_FDECL(wl_seat)
 DEFAULT_DELETER_FDECL(wl_shell)
 DEFAULT_DELETER_FDECL(wl_shell_surface)
-DEFAULT_DELETER_FDECL(wl_seat)
-DEFAULT_DELETER_FDECL(wl_pointer)
+DEFAULT_DELETER_FDECL(wl_shm)
+DEFAULT_DELETER_FDECL(wl_shm_pool)
+DEFAULT_DELETER_FDECL(wl_subcompositor)
+DEFAULT_DELETER_FDECL(wl_subsurface)
+DEFAULT_DELETER_FDECL(wl_surface)
 DEFAULT_DELETER_FDECL(wl_touch)
-DEFAULT_DELETER_FDECL(wl_callback)
 DEFAULT_DELETER_FDECL(wp_presentation)
 DEFAULT_DELETER_FDECL(struct wp_presentation_feedback)
 DEFAULT_DELETER_FDECL(zwp_linux_buffer_params_v1)
 DEFAULT_DELETER_FDECL(zwp_linux_dmabuf_v1)
 
 #if defined(OZONE_PLATFORM_GBM)
-DEFAULT_DELETER_FDECL(gbm_device)
 DEFAULT_DELETER_FDECL(gbm_bo)
+DEFAULT_DELETER_FDECL(gbm_device)
 #endif
 
 namespace exo {

components/exo/wayland/clients/rects.cc

diff --git a/components/exo/wayland/clients/rects.cc b/components/exo/wayland/clients/rects.cc
index 342d8e66..04281ed 100644
--- a/components/exo/wayland/clients/rects.cc
+++ b/components/exo/wayland/clients/rects.cc
@@ -343,9 +343,10 @@
         // since last frame. Latest event at the top.
         int y = 0;
         // Note: Rounding up to ensure we cover the whole canvas.
-        int h = (height_ + (event_times.size() / 2)) / event_times.size();
+        int h =
+            (size_.height() + (event_times.size() / 2)) / event_times.size();
         while (!event_times.empty()) {
-          SkIRect rect = SkIRect::MakeXYWH(0, y, width_, h);
+          SkIRect rect = SkIRect::MakeXYWH(0, y, size_.width(), h);
           SkPaint paint;
           paint.setColor(SkColorSetRGB((event_times.back() & 0x0000ff) >> 0,
                                        (event_times.back() & 0x00ff00) >> 8,
@@ -361,8 +362,8 @@
       }
 
       // Draw rotating rects.
-      SkScalar half_width = SkScalarHalf(width_);
-      SkScalar half_height = SkScalarHalf(height_);
+      SkScalar half_width = SkScalarHalf(size_.width());
+      SkScalar half_height = SkScalarHalf(size_.height());
       SkIRect rect = SkIRect::MakeXYWH(-SkScalarHalf(half_width),
                                        -SkScalarHalf(half_height), half_width,
                                        half_height);
@@ -383,7 +384,7 @@
       // Draw FPS counter.
       if (show_fps_counter) {
         canvas->drawText(fps_counter_text.c_str(), fps_counter_text.length(),
-                         width_ - 48, 32, text_paint);
+                         size_.width() - 48, 32, text_paint);
       }
       GrContext* gr_context = gr_context_.get();
       if (gr_context) {
@@ -417,7 +418,8 @@
 
       wl_surface* surface = surface_.get();
       wl_surface_set_buffer_scale(surface, scale_);
-      wl_surface_damage(surface, 0, 0, width_ / scale_, height_ / scale_);
+      wl_surface_damage(surface, 0, 0, size_.width() / scale_,
+                        size_.height() / scale_);
       wl_surface_attach(surface, frame->buffer->buffer.get(), 0, 0);
 
 #if defined(OZONE_PLATFORM_GBM)

components/exo/wayland/clients/simple.cc

diff --git a/components/exo/wayland/clients/simple.cc b/components/exo/wayland/clients/simple.cc
index a437c07..39a1163f 100644
--- a/components/exo/wayland/clients/simple.cc
+++ b/components/exo/wayland/clients/simple.cc
@@ -56,7 +56,8 @@
       glFinish();
     }
     wl_surface_set_buffer_scale(surface_.get(), scale_);
-    wl_surface_damage(surface_.get(), 0, 0, width_ / scale_, height_ / scale_);
+    wl_surface_damage(surface_.get(), 0, 0, size_.width() / scale_,
+                      size_.height() / scale_);
     wl_surface_attach(surface_.get(), buffer->buffer.get(), 0, 0);
 
     frame_callback.reset(wl_surface_frame(surface_.get()));

components/exo/wayland/clients/subsurface.cc

diff --git a/components/exo/wayland/clients/subsurface.cc b/components/exo/wayland/clients/subsurface.cc
new file mode 100644
index 0000000..c9f686ea
--- /dev/null
+++ b/components/exo/wayland/clients/subsurface.cc
@@ -0,0 +1,157 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/at_exit.h"
+#include "base/command_line.h"
+#include "components/exo/wayland/clients/client_base.h"
+#include "components/exo/wayland/clients/client_helper.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkSurface.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+#include "ui/gl/gl_bindings.h"
+
+namespace exo {
+namespace wayland {
+namespace clients {
+namespace {
+
+void FrameCallback(void* data, wl_callback* callback, uint32_t time) {
+  bool* callback_pending = static_cast<bool*>(data);
+  *callback_pending = false;
+}
+
+}  // namespace
+
+// This demo testes subsurface features of exo.
+// For the first 200 frames: we animate parent surface, child_surface and
+// child_surface's position.
+// For 200-400 frames: we animate parent surface and child_surface's position.
+// For 400-600 frames: we only animate child_surface's position.
+// After 600 frames: we still animate child_surface's position, but don't call
+// commit on parent surface. So the window will stop updating.
+class SubSurfaceClient : public ClientBase {
+ public:
+  SubSurfaceClient() = default;
+  ~SubSurfaceClient() override = default;
+
+  void Run(const ClientBase::InitParams& params);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SubSurfaceClient);
+};
+
+void SubSurfaceClient::Run(const ClientBase::InitParams& params) {
+  if (!ClientBase::Init(params))
+    return;
+
+  std::unique_ptr<wl_surface> child_surface(static_cast<wl_surface*>(
+      wl_compositor_create_surface(globals_.compositor.get())));
+
+  std::unique_ptr<wl_subsurface> subsurface(
+      static_cast<wl_subsurface*>(wl_subcompositor_get_subsurface(
+          globals_.subcompositor.get(), child_surface.get(), surface_.get())));
+
+  if (!child_surface || !subsurface) {
+    LOG(ERROR) << "Can't create subsurface";
+    return;
+  }
+
+  constexpr int32_t kSubsurfaceWidth = 128;
+  constexpr int32_t kSubsurfaceHeight = 128;
+  auto subbuffer = CreateBuffer(gfx::Size(kSubsurfaceWidth, kSubsurfaceHeight));
+  if (!subbuffer) {
+    LOG(ERROR) << "Failed to create subbuffer";
+    return;
+  }
+
+  bool callback_pending = false;
+  std::unique_ptr<wl_callback> frame_callback;
+  wl_callback_listener frame_listener = {FrameCallback};
+
+  size_t frame_count = 0;
+  do {
+    if (callback_pending && frame_count < 600)
+      continue;
+
+    // Only generate frames to child surface for the first 200 frames.
+    if (frame_count < 200) {
+      SkScalar half_width = SkScalarHalf(kSubsurfaceWidth);
+      SkScalar half_height = SkScalarHalf(kSubsurfaceHeight);
+      SkIRect rect = SkIRect::MakeXYWH(-SkScalarHalf(half_width),
+                                       -SkScalarHalf(half_height), half_width,
+                                       half_height);
+      // Rotation speed (degrees/frame).
+      const double kRotationSpeed = 5.;
+      SkScalar rotation = frame_count * kRotationSpeed;
+      SkCanvas* canvas = subbuffer->sk_surface->getCanvas();
+      canvas->save();
+      canvas->clear(SK_ColorBLACK);
+      SkPaint paint;
+      paint.setColor(SkColorSetA(SK_ColorYELLOW, 0xA0));
+      canvas->translate(half_width, half_height);
+      canvas->rotate(rotation);
+      canvas->drawIRect(rect, paint);
+      canvas->restore();
+      if (gr_context_) {
+        gr_context_->flush();
+        glFinish();
+      }
+      wl_surface_set_buffer_scale(child_surface.get(), scale_);
+      wl_surface_damage(child_surface.get(), 0, 0, kSubsurfaceWidth / scale_,
+                        kSubsurfaceHeight / scale_);
+      wl_surface_attach(child_surface.get(), subbuffer->buffer.get(), 0, 0);
+      wl_surface_commit(child_surface.get());
+    }
+
+    // Only generate frames to parent surface for the first 400 frames.
+    if (frame_count < 400) {
+      Buffer* buffer = buffers_.front().get();
+      SkCanvas* canvas = buffer->sk_surface->getCanvas();
+      static const SkColor kColors[] = {SK_ColorRED, SK_ColorBLACK};
+      canvas->clear(kColors[frame_count % arraysize(kColors)]);
+      if (gr_context_) {
+        gr_context_->flush();
+        glFinish();
+      }
+      wl_surface_set_buffer_scale(surface_.get(), scale_);
+      wl_surface_damage(surface_.get(), 0, 0, size_.width() / scale_,
+                        size_.height() / scale_);
+      wl_surface_attach(surface_.get(), buffer->buffer.get(), 0, 0);
+
+      callback_pending = true;
+      frame_callback.reset(wl_surface_frame(surface_.get()));
+      wl_callback_add_listener(frame_callback.get(), &frame_listener,
+                               &callback_pending);
+    }
+
+    // Always animate subsurface position.
+    wl_subsurface_set_position(subsurface.get(), frame_count % 50,
+                               frame_count % 50);
+
+    // Only commit changes for the first 600 frames.
+    if (frame_count < 600)
+      wl_surface_commit(surface_.get());
+
+    wl_display_flush(display_.get());
+    ++frame_count;
+  } while (wl_display_dispatch(display_.get()) != -1);
+}
+
+}  // namespace clients
+}  // namespace wayland
+}  // namespace exo
+
+int main(int argc, char* argv[]) {
+  base::AtExitManager exit_manager;
+  base::CommandLine::Init(argc, argv);
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+
+  exo::wayland::clients::ClientBase::InitParams params;
+  if (!params.FromCommandLine(*command_line))
+    return 1;
+
+  exo::wayland::clients::SubSurfaceClient client;
+  client.Run(params);
+  return 1;
+}

components/offline_pages/core/client_id.cc

diff --git a/components/offline_pages/core/client_id.cc b/components/offline_pages/core/client_id.cc
index df606341..e4f988c 100644
--- a/components/offline_pages/core/client_id.cc
+++ b/components/offline_pages/core/client_id.cc
@@ -4,6 +4,8 @@
 
 #include "components/offline_pages/core/client_id.h"
 
+#include <ostream>
+
 namespace offline_pages {
 
 ClientId::ClientId() {}
@@ -22,4 +24,16 @@
   return name_space < client_id.name_space;
 }
 
+std::string ClientId::ToString() const {
+  return std::string("ClientId(")
+      .append(name_space)
+      .append(", ")
+      .append(id)
+      .append(")");
+}
+
+std::ostream& operator<<(std::ostream& out, const ClientId& cid) {
+  return out << cid.ToString();
+}
+
 }  // namespace offline_pages

components/offline_pages/core/client_id.h

diff --git a/components/offline_pages/core/client_id.h b/components/offline_pages/core/client_id.h
index 8c749828..3493375 100644
--- a/components/offline_pages/core/client_id.h
+++ b/components/offline_pages/core/client_id.h
@@ -5,6 +5,7 @@
 #ifndef COMPONENTS_OFFLINE_PAGES_CORE_CLIENT_ID_H_
 #define COMPONENTS_OFFLINE_PAGES_CORE_CLIENT_ID_H_
 
+#include <iosfwd>
 #include <string>
 
 namespace offline_pages {
@@ -21,6 +22,8 @@
 
   bool operator<(const ClientId& client_id) const;
 
+  std::string ToString() const;
+
   // The namespace that identifies the client (of course 'namespace' is a
   // reserved word, so...).
   std::string name_space;
@@ -31,6 +34,8 @@
   std::string id;
 };
 
+std::ostream& operator<<(std::ostream& out, const ClientId& cid);
+
 }  // namespace offline_pages
 
 #endif  // COMPONENTS_OFFLINE_PAGES_CORE_CLIENT_ID_H_
\ No newline at end of file

components/offline_pages/core/prefetch/BUILD.gn

diff --git a/components/offline_pages/core/prefetch/BUILD.gn b/components/offline_pages/core/prefetch/BUILD.gn
index 8e65f7a..5368f00 100644
--- a/components/offline_pages/core/prefetch/BUILD.gn
+++ b/components/offline_pages/core/prefetch/BUILD.gn
@@ -39,8 +39,6 @@
     "prefetch_gcm_handler.h",
     "prefetch_importer.cc",
     "prefetch_importer.h",
-    "prefetch_item.cc",
-    "prefetch_item.h",
     "prefetch_network_request_factory.h",
     "prefetch_network_request_factory_impl.cc",
     "prefetch_network_request_factory_impl.h",
@@ -90,6 +88,8 @@
   sources = [
     "mock_prefetch_item_generator.cc",
     "mock_prefetch_item_generator.h",
+    "prefetch_item.cc",
+    "prefetch_item.h",
     "prefetch_request_test_base.cc",
     "prefetch_request_test_base.h",
     "prefetch_service_test_taco.cc",

components/offline_pages/core/prefetch/mock_prefetch_item_generator.cc

diff --git a/components/offline_pages/core/prefetch/mock_prefetch_item_generator.cc b/components/offline_pages/core/prefetch/mock_prefetch_item_generator.cc
index 4547b292..4a23fba 100644
--- a/components/offline_pages/core/prefetch/mock_prefetch_item_generator.cc
+++ b/components/offline_pages/core/prefetch/mock_prefetch_item_generator.cc
@@ -8,7 +8,6 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "components/offline_pages/core/client_id.h"
-#include "components/offline_pages/core/prefetch/store/prefetch_store_utils.h"
 #include "url/gurl.h"
 
 namespace offline_pages {
@@ -37,7 +36,7 @@
   // Values set with non prefix based values.
   new_item.state = state;
   new_item.guid = base::GenerateGUID();
-  new_item.offline_id = PrefetchStoreUtils::GenerateOfflineId();
+  new_item.offline_id = GenerateTestOfflineId();
   new_item.creation_time = base::Time::Now();
   new_item.freshness_time = new_item.creation_time;
 
@@ -63,4 +62,8 @@
   return new_item;
 }
 
+int64_t MockPrefetchItemGenerator::GenerateTestOfflineId() {
+  return ++offline_id_counter_;
+}
+
 }  // namespace offline_pages

components/offline_pages/core/prefetch/mock_prefetch_item_generator.h

diff --git a/components/offline_pages/core/prefetch/mock_prefetch_item_generator.h b/components/offline_pages/core/prefetch/mock_prefetch_item_generator.h
index 67b4650..cd8cf3b 100644
--- a/components/offline_pages/core/prefetch/mock_prefetch_item_generator.h
+++ b/components/offline_pages/core/prefetch/mock_prefetch_item_generator.h
@@ -29,9 +29,14 @@
   ~MockPrefetchItemGenerator();
 
   // Creates a new item using all set prefixes and an internal counter to set
-  // reasonable and unique values to all fields.
+  // reasonable and unique values to all fields including the instance-unique
+  // offline ID.
   PrefetchItem CreateItem(PrefetchItemState state);
 
+  // Generates a unique offline ID within the context of this generator
+  // instance. Values will not be unique among different instances.
+  int64_t GenerateTestOfflineId();
+
   // Setters for all prefixes.
   void set_client_namespace(std::string client_namespace) {
     client_namespace_ = client_namespace;
@@ -61,6 +66,10 @@
   std::string final_url_prefix_ = kFinalUrlPrefix;
   std::string operation_name_prefix_ = kOperationNamePrefix;
   std::string archive_body_name_prefix_ = kArchiveBodyNamePrefix;
+
+  // Test offline IDs start at an arbitrary, non-zero value to ease recognizing
+  // generated ID values among other integer values while debugging.
+  int64_t offline_id_counter_ = 1000;
 };
 
 }  // namespace offline_pages

components/offline_pages/core/prefetch/prefetch_item.cc

diff --git a/components/offline_pages/core/prefetch/prefetch_item.cc b/components/offline_pages/core/prefetch/prefetch_item.cc
index 2fcc6a6..dce74a9 100644
--- a/components/offline_pages/core/prefetch/prefetch_item.cc
+++ b/components/offline_pages/core/prefetch/prefetch_item.cc
@@ -4,6 +4,11 @@
 
 #include "components/offline_pages/core/prefetch/prefetch_item.h"
 
+#include <ostream>
+
+#include "base/strings/string_number_conversions.h"
+#include "components/offline_pages/core/offline_time_utils.h"
+
 namespace offline_pages {
 
 PrefetchItem::PrefetchItem() = default;
@@ -42,4 +47,28 @@
   return offline_id < other.offline_id;
 }
 
+std::string PrefetchItem::ToString() const {
+  std::string s("PrefetchItem(");
+  s.append(base::Int64ToString(offline_id)).append(", ");
+  s.append(guid).append(", ");
+  s.append(client_id.ToString()).append(", ");
+  s.append(base::IntToString(static_cast<int>(state))).append(", ");
+  s.append(url.possibly_invalid_spec()).append(", ");
+  s.append(final_archived_url.possibly_invalid_spec()).append(", ");
+  s.append(base::IntToString(generate_bundle_attempts)).append(", ");
+  s.append(base::IntToString(get_operation_attempts)).append(", ");
+  s.append(base::IntToString(download_initiation_attempts)).append(", ");
+  s.append(operation_name).append(", ");
+  s.append(archive_body_name).append(", ");
+  s.append(base::IntToString(archive_body_length)).append(", ");
+  s.append(base::Int64ToString(ToDatabaseTime(creation_time))).append(", ");
+  s.append(base::Int64ToString(ToDatabaseTime(freshness_time))).append(", ");
+  s.append(base::IntToString(static_cast<int>(error_code))).append(")");
+  return s;
+}
+
+std::ostream& operator<<(std::ostream& out, const PrefetchItem& pi) {
+  return out << pi.ToString();
+}
+
 }  // namespace offline_pages

components/offline_pages/core/prefetch/prefetch_item.h

diff --git a/components/offline_pages/core/prefetch/prefetch_item.h b/components/offline_pages/core/prefetch/prefetch_item.h
index 3a64e11..d40e90a 100644
--- a/components/offline_pages/core/prefetch/prefetch_item.h
+++ b/components/offline_pages/core/prefetch/prefetch_item.h
@@ -6,6 +6,7 @@
 #define COMPONENTS_OFFLINE_PAGES_CORE_PREFETCH_PREFETCH_ITEM_H_
 
 #include <stdint.h>
+#include <iosfwd>
 #include <string>
 
 #include "base/files/file_path.h"
@@ -35,6 +36,8 @@
   bool operator!=(const PrefetchItem& other) const;
   bool operator<(const PrefetchItem& other) const;
 
+  std::string ToString() const;
+
   // Primary key that stays consistent between prefetch item, request and
   // offline page.
   int64_t offline_id = 0;
@@ -113,6 +116,8 @@
   int64_t file_size = 0;
 };
 
+std::ostream& operator<<(std::ostream& out, const PrefetchItem& pi);
+
 }  // namespace offline_pages
 
 #endif  // COMPONENTS_OFFLINE_PAGES_CORE_PREFETCH_PREFETCH_ITEM_H_

components/offline_pages/core/prefetch/store/prefetch_store.cc

diff --git a/components/offline_pages/core/prefetch/store/prefetch_store.cc b/components/offline_pages/core/prefetch/store/prefetch_store.cc
index 43c16a6..e0e3869 100644
--- a/components/offline_pages/core/prefetch/store/prefetch_store.cc
+++ b/components/offline_pages/core/prefetch/store/prefetch_store.cc
@@ -14,7 +14,6 @@
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/offline_pages/core/offline_store_types.h"
-#include "components/offline_pages/core/prefetch/prefetch_item.h"
 #include "components/offline_pages/core/prefetch/store/prefetch_store_utils.h"
 #include "sql/connection.h"
 #include "sql/meta_table.h"

components/offline_pages/core/prefetch/store/prefetch_store_utils.cc

diff --git a/components/offline_pages/core/prefetch/store/prefetch_store_utils.cc b/components/offline_pages/core/prefetch/store/prefetch_store_utils.cc
index 65a9024..a124894 100644
--- a/components/offline_pages/core/prefetch/store/prefetch_store_utils.cc
+++ b/components/offline_pages/core/prefetch/store/prefetch_store_utils.cc
@@ -7,7 +7,6 @@
 #include <limits>
 
 #include "base/rand_util.h"
-#include "components/offline_pages/core/prefetch/prefetch_item.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 

components/payments/core/features.cc

diff --git a/components/payments/core/features.cc b/components/payments/core/features.cc
index c51d57f..c2ef263 100644
--- a/components/payments/core/features.cc
+++ b/components/payments/core/features.cc
@@ -10,6 +10,9 @@
 #if defined(OS_IOS)
 const base::Feature kWebPayments{"WebPayments",
                                  base::FEATURE_DISABLED_BY_DEFAULT};
+
+const base::Feature kWebPaymentsNativeApps{"WebPaymentsNativeApps",
+                                           base::FEATURE_DISABLED_BY_DEFAULT};
 #endif
 
 const base::Feature kWebPaymentsMethodSectionOrderV2{

components/payments/core/features.h

diff --git a/components/payments/core/features.h b/components/payments/core/features.h
index 4af9cf12..a7e4a48cf 100644
--- a/components/payments/core/features.h
+++ b/components/payments/core/features.h
@@ -14,6 +14,9 @@
 #if defined(OS_IOS)
 // Used to control the state of the Payment Request API feature.
 extern const base::Feature kWebPayments;
+
+// Used to control the support for iOS third party apps as payment methods.
+extern const base::Feature kWebPaymentsNativeApps;
 #endif
 
 // Used to control payment method section order on payment request UI. Payment

components/policy/resources/policy_templates.json

diff --git a/components/policy/resources/policy_templates.json b/components/policy/resources/policy_templates.json
index 451c477..c36c1e9 100644
--- a/components/policy/resources/policy_templates.json
+++ b/components/policy/resources/policy_templates.json
@@ -143,7 +143,7 @@
 #   persistent IDs for all fields (but not for groups!) are needed. These are
 #   specified by the 'id' keys of each policy. NEVER CHANGE EXISTING IDs,
 #   because doing so would break the deployed wire format!
-#   For your editing convenience: highest ID currently used: 379
+#   For your editing convenience: highest ID currently used: 380
 #   And don't forget to also update the EnterprisePolicies enum of
 #   histograms.xml (run 'python tools/metrics/histograms/update_policies.py').
 #
@@ -9854,8 +9854,89 @@
           'desc': '''Determine the name advertised as a <ph name="PRODUCT_NAME">Google Cast</ph> destination.
 
           If this policy is set to a non empty string, that string will be used as the name of the <ph name="PRODUCT_NAME">Google Cast</ph> destination. Otherwise, the destination name will be the device name. If this policy is not set, the destination name will be the device name and the device owner will be allowed to change it. The name is limited to 24 characters.'''
-        },
+        }
       ]
+    },
+    {
+      'name': 'DeviceOffHours',
+      'type': 'dict',
+      'schema': {
+        'type': 'object',
+        'properties': {
+          'interval': {
+            'type': 'array',
+            'items': {
+              'type': 'object',
+              'id': 'DeviceOffHoursIntervals',
+              'properties': {
+                'start': {
+                  'type': 'object',
+                  'id': 'WeeklyTime',
+                  'properties': {
+                    'weekday': {
+                      'type': 'string',
+                      'enum': [
+                        'MONDAY',
+                        'TUESDAY',
+                        'WEDNESDAY',
+                        'THURSDAY',
+                        'FRIDAY',
+                        'SATURDAY',
+                        'SUNDAY'
+                      ]
+                    },
+                    'time': { 'type': 'integer'}
+                  }
+                },
+                'end': {
+                  '$ref': 'WeeklyTime'
+                }
+              }
+            }
+          },
+          'timezone': { 'type': 'string' },
+          'ignored_policy': {
+            'type': 'array',
+            'items': { 'type':'string' }
+          }
+        }
+      },
+      'supported_on': ['chrome_os:62-'],
+      'device_only': True,
+      'features': {
+        'dynamic_refresh': True
+      },
+      'example_value': {
+        'interval':
+        [
+          {
+            'start': {
+              'weekday': 'MONDAY',
+              'time': 12840000
+            },
+            'end': {
+              'weekday': 'MONDAY',
+              'time': 21720000
+            }
+          },
+          {
+            'start': {
+              'weekday': 'FRIDAY',
+              'time': 38640000
+            },
+            'end': {
+              'weekday': 'FRIDAY',
+              'time': 57600000
+            }
+          }
+        ],
+        'timezone': 'GMT',
+        'ignored_policy': ['allow_new_users', 'guest_mode_enabled']
+      },
+      'id': 380,
+      'caption': '''Off hours intervals when device OffHours |ignored_policy| are released''',
+      'tags': [],
+      'desc': '''If "OffHours" policy is set, then the specified device policies are ignored (use the default settings of these policies) during the defined time intervals. Device policies are re-applied by Chrome on every event when "OffHours" period starts or ends. User will be notified and forced to sign out when "OffHours" time end and device policy settings are changed (i.e. when user is logged in not with an allowed account).''',
     }
   ],
   'messages': {

components/viz/client/client_layer_tree_frame_sink.cc

diff --git a/components/viz/client/client_layer_tree_frame_sink.cc b/components/viz/client/client_layer_tree_frame_sink.cc
index 3a718cbe..6348585a 100644
--- a/components/viz/client/client_layer_tree_frame_sink.cc
+++ b/components/viz/client/client_layer_tree_frame_sink.cc
@@ -6,6 +6,7 @@
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
+#include "base/trace_event/trace_event.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/layer_tree_frame_sink_client.h"
 #include "components/viz/client/hit_test_data_provider.h"
@@ -121,10 +122,19 @@
         local_surface_id_provider_->GetLocalSurfaceIdForFrame(frame);
   }
 
+  TRACE_EVENT_FLOW_BEGIN0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+                          "SubmitCompositorFrame",
+                          local_surface_id_.local_id());
+  bool tracing_enabled;
+  TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+                                     &tracing_enabled);
+
   // TODO(gklassen): Use hit_test_data_provider_->GetHitTestData() to obtain
   // hit-test data and send to |compositor_frame_sink_|.
-  compositor_frame_sink_->SubmitCompositorFrame(local_surface_id_,
-                                                std::move(frame), nullptr);
+  compositor_frame_sink_->SubmitCompositorFrame(
+      local_surface_id_, std::move(frame), nullptr,
+      tracing_enabled ? base::TimeTicks::Now().since_origin().InMicroseconds()
+                      : 0);
 }
 
 void ClientLayerTreeFrameSink::DidNotProduceFrame(const BeginFrameAck& ack) {

components/viz/common/surfaces/surface_info.h

diff --git a/components/viz/common/surfaces/surface_info.h b/components/viz/common/surfaces/surface_info.h
index 1e21fda..b40092b 100644
--- a/components/viz/common/surfaces/surface_info.h
+++ b/components/viz/common/surfaces/surface_info.h
@@ -13,13 +13,11 @@
 struct ParamTraits;
 }  // namespace IPC
 
-namespace cc {
+namespace viz {
+
 namespace mojom {
 class SurfaceInfoDataView;
-}
-}  // namespace cc
-
-namespace viz {
+}  // namespace mojom
 
 // This class contains information about the surface that is being embedded.
 class SurfaceInfo {
@@ -50,7 +48,7 @@
   const gfx::Size& size_in_pixels() const { return size_in_pixels_; }
 
  private:
-  friend struct mojo::StructTraits<cc::mojom::SurfaceInfoDataView, SurfaceInfo>;
+  friend struct mojo::StructTraits<mojom::SurfaceInfoDataView, SurfaceInfo>;
   friend struct IPC::ParamTraits<SurfaceInfo>;
 
   SurfaceId id_;

components/viz/service/display/display_scheduler.cc

diff --git a/components/viz/service/display/display_scheduler.cc b/components/viz/service/display/display_scheduler.cc
index 2b52e82..012e3900 100644
--- a/components/viz/service/display/display_scheduler.cc
+++ b/components/viz/service/display/display_scheduler.cc
@@ -280,6 +280,8 @@
 void DisplayScheduler::OnFirstSurfaceActivation(
     const SurfaceInfo& surface_info) {}
 
+void DisplayScheduler::OnSurfaceActivated(const SurfaceId& surface_id) {}
+
 void DisplayScheduler::OnSurfaceDestroyed(const SurfaceId& surface_id) {
   auto it = surface_states_.find(surface_id);
   if (it == surface_states_.end())

components/viz/service/display/display_scheduler.h

diff --git a/components/viz/service/display/display_scheduler.h b/components/viz/service/display/display_scheduler.h
index d341df0..3e82f91 100644
--- a/components/viz/service/display/display_scheduler.h
+++ b/components/viz/service/display/display_scheduler.h
@@ -66,6 +66,7 @@
 
   // SurfaceObserver implementation.
   void OnFirstSurfaceActivation(const SurfaceInfo& surface_info) override;
+  void OnSurfaceActivated(const SurfaceId& surface_id) override;
   void OnSurfaceDestroyed(const SurfaceId& surface_id) override;
   bool OnSurfaceDamaged(const SurfaceId& surface_id,
                         const BeginFrameAck& ack) override;

components/viz/service/frame_sinks/compositor_frame_sink_impl.cc

diff --git a/components/viz/service/frame_sinks/compositor_frame_sink_impl.cc b/components/viz/service/frame_sinks/compositor_frame_sink_impl.cc
index d5fbdd5..830ca2c 100644
--- a/components/viz/service/frame_sinks/compositor_frame_sink_impl.cc
+++ b/components/viz/service/frame_sinks/compositor_frame_sink_impl.cc
@@ -37,7 +37,8 @@
 void CompositorFrameSinkImpl::SubmitCompositorFrame(
     const LocalSurfaceId& local_surface_id,
     cc::CompositorFrame frame,
-    mojom::HitTestRegionListPtr hit_test_region_list) {
+    mojom::HitTestRegionListPtr hit_test_region_list,
+    uint64_t submit_time) {
   // TODO(gklassen): Route hit-test data to the appropriate HitTestAggregator.
   if (!support_->SubmitCompositorFrame(local_surface_id, std::move(frame))) {
     compositor_frame_sink_binding_.CloseWithReason(

components/viz/service/frame_sinks/compositor_frame_sink_impl.h

diff --git a/components/viz/service/frame_sinks/compositor_frame_sink_impl.h b/components/viz/service/frame_sinks/compositor_frame_sink_impl.h
index 49793396..f340824 100644
--- a/components/viz/service/frame_sinks/compositor_frame_sink_impl.h
+++ b/components/viz/service/frame_sinks/compositor_frame_sink_impl.h
@@ -33,10 +33,10 @@
 
   // mojom::CompositorFrameSink:
   void SetNeedsBeginFrame(bool needs_begin_frame) override;
-  void SubmitCompositorFrame(
-      const LocalSurfaceId& local_surface_id,
-      cc::CompositorFrame frame,
-      mojom::HitTestRegionListPtr hit_test_region_list) override;
+  void SubmitCompositorFrame(const LocalSurfaceId& local_surface_id,
+                             cc::CompositorFrame frame,
+                             mojom::HitTestRegionListPtr hit_test_region_list,
+                             uint64_t submit_time) override;
   void DidNotProduceFrame(const BeginFrameAck& begin_frame_ack) override;
 
  private:

components/viz/service/frame_sinks/compositor_frame_sink_support.cc

diff --git a/components/viz/service/frame_sinks/compositor_frame_sink_support.cc b/components/viz/service/frame_sinks/compositor_frame_sink_support.cc
index cdddcca..c91bc89 100644
--- a/components/viz/service/frame_sinks/compositor_frame_sink_support.cc
+++ b/components/viz/service/frame_sinks/compositor_frame_sink_support.cc
@@ -58,17 +58,11 @@
 }
 
 void CompositorFrameSinkSupport::OnSurfaceActivated(Surface* surface) {
+  DCHECK(surface);
   DCHECK(surface->HasActiveFrame());
-  const cc::CompositorFrame& frame = surface->GetActiveFrame();
   DCHECK(surface->active_referenced_surfaces());
   UpdateSurfaceReferences(surface->surface_id().local_surface_id(),
                           *surface->active_referenced_surfaces());
-  if (!surface_manager_->SurfaceModified(surface->surface_id(),
-                                         frame.metadata.begin_frame_ack)) {
-    TRACE_EVENT_INSTANT0("cc", "Damage not visible.", TRACE_EVENT_SCOPE_THREAD);
-    surface->RunDrawCallback();
-  }
-  surface_manager_->SurfaceActivated(surface);
 }
 
 void CompositorFrameSinkSupport::RefResources(

components/viz/service/frame_sinks/frame_sink_manager_impl.cc

diff --git a/components/viz/service/frame_sinks/frame_sink_manager_impl.cc b/components/viz/service/frame_sinks/frame_sink_manager_impl.cc
index 749d791..46b7b82a 100644
--- a/components/viz/service/frame_sinks/frame_sink_manager_impl.cc
+++ b/components/viz/service/frame_sinks/frame_sink_manager_impl.cc
@@ -334,6 +334,8 @@
     client_->OnFirstSurfaceActivation(surface_info);
 }
 
+void FrameSinkManagerImpl::OnSurfaceActivated(const SurfaceId& surface_id) {}
+
 bool FrameSinkManagerImpl::OnSurfaceDamaged(const SurfaceId& surface_id,
                                             const BeginFrameAck& ack) {
   return false;

components/viz/service/frame_sinks/frame_sink_manager_impl.h

diff --git a/components/viz/service/frame_sinks/frame_sink_manager_impl.h b/components/viz/service/frame_sinks/frame_sink_manager_impl.h
index dae82bf..c47489c 100644
--- a/components/viz/service/frame_sinks/frame_sink_manager_impl.h
+++ b/components/viz/service/frame_sinks/frame_sink_manager_impl.h
@@ -113,6 +113,7 @@
 
   // SurfaceObserver implementation.
   void OnFirstSurfaceActivation(const SurfaceInfo& surface_info) override;
+  void OnSurfaceActivated(const SurfaceId& surface_id) override;
   bool OnSurfaceDamaged(const SurfaceId& surface_id,
                         const BeginFrameAck& ack) override;
   void OnSurfaceDiscarded(const SurfaceId& surface_id) override;

components/viz/service/frame_sinks/root_compositor_frame_sink_impl.cc

diff --git a/components/viz/service/frame_sinks/root_compositor_frame_sink_impl.cc b/components/viz/service/frame_sinks/root_compositor_frame_sink_impl.cc
index 7065fba5..11b9813a 100644
--- a/components/viz/service/frame_sinks/root_compositor_frame_sink_impl.cc
+++ b/components/viz/service/frame_sinks/root_compositor_frame_sink_impl.cc
@@ -81,7 +81,8 @@
 void RootCompositorFrameSinkImpl::SubmitCompositorFrame(
     const LocalSurfaceId& local_surface_id,
     cc::CompositorFrame frame,
-    mojom::HitTestRegionListPtr hit_test_region_list) {
+    mojom::HitTestRegionListPtr hit_test_region_list,
+    uint64_t submit_time) {
   // This call to SubmitCompositorFrame is only used for CompositorFrames
   // created by FrameGenerator that do not require hit test information.
   DCHECK(!hit_test_region_list);

components/viz/service/frame_sinks/root_compositor_frame_sink_impl.h

diff --git a/components/viz/service/frame_sinks/root_compositor_frame_sink_impl.h b/components/viz/service/frame_sinks/root_compositor_frame_sink_impl.h
index 38eaeee..e8bc685 100644
--- a/components/viz/service/frame_sinks/root_compositor_frame_sink_impl.h
+++ b/components/viz/service/frame_sinks/root_compositor_frame_sink_impl.h
@@ -53,10 +53,10 @@
 
   // mojom::CompositorFrameSink:
   void SetNeedsBeginFrame(bool needs_begin_frame) override;
-  void SubmitCompositorFrame(
-      const LocalSurfaceId& local_surface_id,
-      cc::CompositorFrame frame,
-      mojom::HitTestRegionListPtr hit_test_region_list) override;
+  void SubmitCompositorFrame(const LocalSurfaceId& local_surface_id,
+                             cc::CompositorFrame frame,
+                             mojom::HitTestRegionListPtr hit_test_region_list,
+                             uint64_t submit_time) override;
   void DidNotProduceFrame(const BeginFrameAck& begin_frame_ack) override;
 
   // HitTestAggregatorDelegate:

components/viz/service/frame_sinks/surface_synchronization_unittest.cc

diff --git a/components/viz/service/frame_sinks/surface_synchronization_unittest.cc b/components/viz/service/frame_sinks/surface_synchronization_unittest.cc
index 2dcd8ea7..b771cb5 100644
--- a/components/viz/service/frame_sinks/surface_synchronization_unittest.cc
+++ b/components/viz/service/frame_sinks/surface_synchronization_unittest.cc
@@ -1606,6 +1606,7 @@
   EXPECT_TRUE(parent_surface()->has_deadline());
   EXPECT_TRUE(parent_surface()->HasActiveFrame());
   EXPECT_TRUE(parent_surface()->HasPendingFrame());
+  surface_observer().Reset();
 
   // Destroy the parent CompositorFrameSink. The parent_surface will be kept
   // alive by the display.
@@ -1626,6 +1627,7 @@
   // The parent surface stays alive through the display.
   parent_surface = GetSurfaceForId(parent_id);
   EXPECT_NE(nullptr, parent_surface);
+  EXPECT_TRUE(surface_observer().IsSurfaceDamaged(parent_id));
 
   // Submitting a new CompositorFrame to the display should free the parent.
   display_support().SubmitCompositorFrame(display_id.local_surface_id(),

components/viz/service/hit_test/hit_test_aggregator.h

diff --git a/components/viz/service/hit_test/hit_test_aggregator.h b/components/viz/service/hit_test/hit_test_aggregator.h
index b5d68146..787d4a7 100644
--- a/components/viz/service/hit_test/hit_test_aggregator.h
+++ b/components/viz/service/hit_test/hit_test_aggregator.h
@@ -49,6 +49,7 @@
  protected:
   // SurfaceObserver:
   void OnFirstSurfaceActivation(const SurfaceInfo& surface_info) override {}
+  void OnSurfaceActivated(const SurfaceId& surface_id) override {}
   void OnSurfaceDestroyed(const SurfaceId& surface_id) override {}
   bool OnSurfaceDamaged(const SurfaceId& surface_id,
                         const BeginFrameAck& ack) override;

components/viz/service/surfaces/surface.cc

diff --git a/components/viz/service/surfaces/surface.cc b/components/viz/service/surfaces/surface.cc
index 4218298..2c964846 100644
--- a/components/viz/service/surfaces/surface.cc
+++ b/components/viz/service/surfaces/surface.cc
@@ -258,13 +258,10 @@
     surface_manager_->FirstSurfaceActivation(surface_info_);
   }
 
-  // TODO(fsamuel): If |surface_client_| is not available then we will not
-  // immediately generate a display frame once the cc::CompositorFrame here
-  // activates. This isn't a major issue though because this would only
-  // happen if the client that generated the surface has went away and so
-  // we likely don't care to preserve the surface for long anyway.
   if (surface_client_)
     surface_client_->OnSurfaceActivated(this);
+
+  surface_manager_->SurfaceActivated(this);
 }
 
 void Surface::UpdateActivationDependencies(

components/viz/service/surfaces/surface_manager.cc

diff --git a/components/viz/service/surfaces/surface_manager.cc b/components/viz/service/surfaces/surface_manager.cc
index 3504721..dee574a 100644
--- a/components/viz/service/surfaces/surface_manager.cc
+++ b/components/viz/service/surfaces/surface_manager.cc
@@ -439,6 +439,16 @@
 }
 
 void SurfaceManager::SurfaceActivated(Surface* surface) {
+  // Trigger a display frame if necessary.
+  const cc::CompositorFrame& frame = surface->GetActiveFrame();
+  if (!SurfaceModified(surface->surface_id(), frame.metadata.begin_frame_ack)) {
+    TRACE_EVENT_INSTANT0("cc", "Damage not visible.", TRACE_EVENT_SCOPE_THREAD);
+    surface->RunDrawCallback();
+  }
+
+  for (auto& observer : observer_list_)
+    observer.OnSurfaceActivated(surface->surface_id());
+
   dependency_tracker_.OnSurfaceActivated(surface);
 }
 

components/viz/service/surfaces/surface_observer.h

diff --git a/components/viz/service/surfaces/surface_observer.h b/components/viz/service/surfaces/surface_observer.h
index 30e144bb..0bffb34 100644
--- a/components/viz/service/surfaces/surface_observer.h
+++ b/components/viz/service/surfaces/surface_observer.h
@@ -14,14 +14,17 @@
 
 class SurfaceObserver {
  public:
-  // Runs when a CompositorFrame with a new SurfaceId activates for the first
+  // Called when a CompositorFrame with a new SurfaceId activates for the first
   // time.
   virtual void OnFirstSurfaceActivation(const SurfaceInfo& surface_info) = 0;
 
-  // Runs when a Surface was marked to be destroyed.
+  // Called when a CompositorFrame within |surface| activates.
+  virtual void OnSurfaceActivated(const SurfaceId& surface_id) = 0;
+
+  // Called when a Surface was marked to be destroyed.
   virtual void OnSurfaceDestroyed(const SurfaceId& surface_id) = 0;
 
-  // Runs when a Surface is modified, e.g. when a CompositorFrame is
+  // Called when a Surface is modified, e.g. when a CompositorFrame is
   // activated, its producer confirms that no CompositorFrame will be submitted
   // in response to a BeginFrame, or a CopyOutputRequest is issued.
   //
@@ -33,12 +36,12 @@
   // Called when a surface is garbage-collected.
   virtual void OnSurfaceDiscarded(const SurfaceId& surface_id) = 0;
 
-  // Runs when a Surface's CompositorFrame producer has received a BeginFrame
+  // Called when a Surface's CompositorFrame producer has received a BeginFrame
   // and, thus, is expected to produce damage soon.
   virtual void OnSurfaceDamageExpected(const SurfaceId& surface_id,
                                        const BeginFrameArgs& args) = 0;
 
-  // Runs when a surface has been added to the aggregated CompositorFrame.
+  // Called when a surface has been added to the aggregated CompositorFrame.
   virtual void OnSurfaceWillDraw(const SurfaceId& surface_id) = 0;
 };
 

components/viz/test/fake_surface_observer.cc

diff --git a/components/viz/test/fake_surface_observer.cc b/components/viz/test/fake_surface_observer.cc
index 8b959d3..3ad1a39 100644
--- a/components/viz/test/fake_surface_observer.cc
+++ b/components/viz/test/fake_surface_observer.cc
@@ -46,4 +46,6 @@
   last_surface_info_ = surface_info;
 }
 
+void FakeSurfaceObserver::OnSurfaceActivated(const SurfaceId& surface_id) {}
+
 }  // namespace viz

components/viz/test/fake_surface_observer.h

diff --git a/components/viz/test/fake_surface_observer.h b/components/viz/test/fake_surface_observer.h
index 5fc19690..ea80642 100644
--- a/components/viz/test/fake_surface_observer.h
+++ b/components/viz/test/fake_surface_observer.h
@@ -39,6 +39,7 @@
   bool OnSurfaceDamaged(const SurfaceId& surface_id,
                         const BeginFrameAck& ack) override;
   void OnFirstSurfaceActivation(const SurfaceInfo& surface_info) override;
+  void OnSurfaceActivated(const SurfaceId& surface_id) override;
   void OnSurfaceDiscarded(const SurfaceId& surface_id) override {}
   void OnSurfaceDestroyed(const SurfaceId& surface_id) override {}
   void OnSurfaceDamageExpected(const SurfaceId& surface_id,

content/browser/BUILD.gn

diff --git a/content/browser/BUILD.gn b/content/browser/BUILD.gn
index 25a9ad8c..b92808dd 100644
--- a/content/browser/BUILD.gn
+++ b/content/browser/BUILD.gn
@@ -664,6 +664,8 @@
     "download/download_stats.h",
     "download/download_task_runner.cc",
     "download/download_task_runner.h",
+    "download/download_utils.cc",
+    "download/download_utils.h",
     "download/download_worker.cc",
     "download/download_worker.h",
     "download/drag_download_file.cc",

content/browser/accessibility/accessibility_ipc_error_browsertest.cc

diff --git a/content/browser/accessibility/accessibility_ipc_error_browsertest.cc b/content/browser/accessibility/accessibility_ipc_error_browsertest.cc
index fabf21c..71007e609 100644
--- a/content/browser/accessibility/accessibility_ipc_error_browsertest.cc
+++ b/content/browser/accessibility/accessibility_ipc_error_browsertest.cc
@@ -159,9 +159,9 @@
 
   // Construct a bad accessibility message that BrowserAccessibilityManager
   // will reject.
-  ui::AXTreeUpdate bad_update;
-  bad_update.node_id_to_clear = -2;
-  std::vector<AXEventNotificationDetails> dummy_accessibility_event_list;
+  std::vector<AXEventNotificationDetails> bad_accessibility_event_list;
+  bad_accessibility_event_list.push_back(AXEventNotificationDetails());
+  bad_accessibility_event_list[0].update.node_id_to_clear = -2;
 
   // We should be able to reset accessibility |max_iterations-1| times
   // (see render_frame_host_impl.cc - kMaxAccessibilityResets),
@@ -172,7 +172,7 @@
     // Send the browser accessibility the bad message.
     BrowserAccessibilityManager* manager =
         frame->GetOrCreateBrowserAccessibilityManager();
-    manager->OnAccessibilityEvents(bad_update, dummy_accessibility_event_list);
+    manager->OnAccessibilityEvents(bad_accessibility_event_list);
 
     // Now the frame should have deleted the BrowserAccessibilityManager.
     ASSERT_EQ(nullptr, frame->browser_accessibility_manager());

content/browser/accessibility/browser_accessibility_mac_unittest.mm

diff --git a/content/browser/accessibility/browser_accessibility_mac_unittest.mm b/content/browser/accessibility/browser_accessibility_mac_unittest.mm
index c7bf8a19..45bec90 100644
--- a/content/browser/accessibility/browser_accessibility_mac_unittest.mm
+++ b/content/browser/accessibility/browser_accessibility_mac_unittest.mm
@@ -67,13 +67,12 @@
     if (!manager_)
       return;
     root_.SetValue(value);
-    ui::AXTreeUpdate update;
-    update.nodes.push_back(root_);
     AXEventNotificationDetails param;
+    param.update.nodes.push_back(root_);
     param.event_type = ui::AX_EVENT_VALUE_CHANGED;
     param.id = root_.id;
     std::vector<AXEventNotificationDetails> events{param};
-    manager_->OnAccessibilityEvents(update, events);
+    manager_->OnAccessibilityEvents(events);
   }
 
   ui::AXNodeData root_;

content/browser/accessibility/browser_accessibility_manager.cc

diff --git a/content/browser/accessibility/browser_accessibility_manager.cc b/content/browser/accessibility/browser_accessibility_manager.cc
index bab71de..adfe70a 100644
--- a/content/browser/accessibility/browser_accessibility_manager.cc
+++ b/content/browser/accessibility/browser_accessibility_manager.cc
@@ -349,8 +349,7 @@
 }
 
 void BrowserAccessibilityManager::OnAccessibilityEvents(
-    const ui::AXTreeUpdate& update,
-    const std::vector<AXEventNotificationDetails>& events) {
+    const std::vector<AXEventNotificationDetails>& details) {
   TRACE_EVENT0("accessibility",
                "BrowserAccessibilityManager::OnAccessibilityEvents");
 
@@ -358,15 +357,18 @@
   if (delegate_ && !use_custom_device_scale_factor_for_testing_)
     device_scale_factor_ = delegate_->AccessibilityGetDeviceScaleFactor();
 
-  // Process the changes to the accessibility tree first.
-  if (!tree_->Unserialize(update)) {
-    if (delegate_) {
-      LOG(ERROR) << tree_->error();
-      delegate_->AccessibilityFatalError();
-    } else {
-      CHECK(false) << tree_->error();
+  // Process all changes to the accessibility tree first.
+  for (uint32_t index = 0; index < details.size(); ++index) {
+    const AXEventNotificationDetails& detail = details[index];
+    if (!tree_->Unserialize(detail.update)) {
+      if (delegate_) {
+        LOG(ERROR) << tree_->error();
+        delegate_->AccessibilityFatalError();
+      } else {
+        CHECK(false) << tree_->error();
+      }
+      return;
     }
-    return;
   }
 
   // If the root's parent is in another accessibility tree but it wasn't
@@ -420,16 +422,16 @@
   // renderer and fires native events based on them.
   //
   // See http://crbug.com/699438 for details.
-  for (uint32_t index = 0; index < events.size(); index++) {
-    const AXEventNotificationDetails& event_detail = events[index];
+  for (uint32_t index = 0; index < details.size(); index++) {
+    const AXEventNotificationDetails& detail = details[index];
 
     // Find the node corresponding to the id that's the target of the
     // event (which may not be the root of the update tree).
-    ui::AXNode* node = tree_->GetFromId(event_detail.id);
+    ui::AXNode* node = tree_->GetFromId(detail.id);
     if (!node)
       continue;
 
-    ui::AXEvent event_type = event_detail.event_type;
+    ui::AXEvent event_type = detail.event_type;
 
 // On Mac and Windows, nearly all events are now fired implicitly,
 // so we should ignore most events from the renderer.

content/browser/accessibility/browser_accessibility_manager.h

diff --git a/content/browser/accessibility/browser_accessibility_manager.h b/content/browser/accessibility/browser_accessibility_manager.h
index 2014369..1624878 100644
--- a/content/browser/accessibility/browser_accessibility_manager.h
+++ b/content/browser/accessibility/browser_accessibility_manager.h
@@ -224,8 +224,7 @@
 
   // Called when the renderer process has notified us of about tree changes.
   virtual void OnAccessibilityEvents(
-      const ui::AXTreeUpdate& update,
-      const std::vector<AXEventNotificationDetails>& events);
+      const std::vector<AXEventNotificationDetails>& details);
 
   // Called when the renderer process updates the location of accessibility
   // objects. Calls SendLocationChangeEvents(), which can be overridden.

content/browser/accessibility/browser_accessibility_manager_mac.h

diff --git a/content/browser/accessibility/browser_accessibility_manager_mac.h b/content/browser/accessibility/browser_accessibility_manager_mac.h
index 36f8d23..d5508ba 100644
--- a/content/browser/accessibility/browser_accessibility_manager_mac.h
+++ b/content/browser/accessibility/browser_accessibility_manager_mac.h
@@ -40,8 +40,7 @@
       BrowserAccessibility* node) override;
 
   void OnAccessibilityEvents(
-      const ui::AXTreeUpdate& update,
-      const std::vector<AXEventNotificationDetails>& events) override;
+      const std::vector<AXEventNotificationDetails>& details) override;
 
   NSView* GetParentView();
 

content/browser/accessibility/browser_accessibility_manager_mac.mm

diff --git a/content/browser/accessibility/browser_accessibility_manager_mac.mm b/content/browser/accessibility/browser_accessibility_manager_mac.mm
index 2afab5c274..068883d 100644
--- a/content/browser/accessibility/browser_accessibility_manager_mac.mm
+++ b/content/browser/accessibility/browser_accessibility_manager_mac.mm
@@ -357,12 +357,11 @@
 }
 
 void BrowserAccessibilityManagerMac::OnAccessibilityEvents(
-    const ui::AXTreeUpdate& update,
-    const std::vector<AXEventNotificationDetails>& events) {
+    const std::vector<AXEventNotificationDetails>& details) {
   text_edits_.clear();
   // Call the base method last as it might delete the tree if it receives an
   // invalid message.
-  BrowserAccessibilityManager::OnAccessibilityEvents(update, events);
+  BrowserAccessibilityManager::OnAccessibilityEvents(details);
 }
 
 void BrowserAccessibilityManagerMac::OnTreeDataChanged(

content/browser/accessibility/browser_accessibility_manager_unittest.cc

diff --git a/content/browser/accessibility/browser_accessibility_manager_unittest.cc b/content/browser/accessibility/browser_accessibility_manager_unittest.cc
index 35edb42..9766abf 100644
--- a/content/browser/accessibility/browser_accessibility_manager_unittest.cc
+++ b/content/browser/accessibility/browser_accessibility_manager_unittest.cc
@@ -238,15 +238,14 @@
   EXPECT_EQ(2, child3_accessible->GetIndexInParent());
 
   // Process a notification containing the changed subtree.
-  ui::AXTreeUpdate update;
-  update.nodes.push_back(tree2_root);
-  update.nodes.push_back(tree2_child0);
-  std::vector<AXEventNotificationDetails> events;
-  events.push_back(AXEventNotificationDetails());
-  AXEventNotificationDetails* event = &events[0];
-  event->event_type = ui::AX_EVENT_CHILDREN_CHANGED;
-  event->id = tree2_root.id;
-  manager->OnAccessibilityEvents(update, events);
+  std::vector<AXEventNotificationDetails> params;
+  params.push_back(AXEventNotificationDetails());
+  AXEventNotificationDetails* msg = &params[0];
+  msg->event_type = ui::AX_EVENT_CHILDREN_CHANGED;
+  msg->update.nodes.push_back(tree2_root);
+  msg->update.nodes.push_back(tree2_child0);
+  msg->id = tree2_root.id;
+  manager->OnAccessibilityEvents(params);
 
   // There should be 5 objects now: the 4 from the new tree, plus the
   // reference to child3 we kept.
@@ -404,16 +403,15 @@
 
   // Process a notification containing the changed subtree rooted at
   // the container.
-  ui::AXTreeUpdate update;
-  update.nodes.push_back(tree2_container);
-  update.nodes.push_back(tree2_child0);
-  update.nodes.push_back(tree2_grandchild0);
-  std::vector<AXEventNotificationDetails> events;
-  events.push_back(AXEventNotificationDetails());
-  AXEventNotificationDetails* event = &events[0];
-  event->event_type = ui::AX_EVENT_CHILDREN_CHANGED;
-  event->id = tree2_container.id;
-  manager->OnAccessibilityEvents(update, events);
+  std::vector<AXEventNotificationDetails> params;
+  params.push_back(AXEventNotificationDetails());
+  AXEventNotificationDetails* msg = &params[0];
+  msg->event_type = ui::AX_EVENT_CHILDREN_CHANGED;
+  msg->update.nodes.push_back(tree2_container);
+  msg->update.nodes.push_back(tree2_child0);
+  msg->update.nodes.push_back(tree2_grandchild0);
+  msg->id = tree2_container.id;
+  manager->OnAccessibilityEvents(params);
 
   // There should be 9 objects now: the 8 from the new tree, plus the
   // reference to child3 we kept.
@@ -503,17 +501,16 @@
   ASSERT_EQ(4, CountedBrowserAccessibility::global_obj_count_);
 
   // Process a notification containing the changed subtree.
-  ui::AXTreeUpdate update;
-  update.nodes.push_back(tree2_1);
-  update.nodes.push_back(tree2_4);
-  update.nodes.push_back(tree2_5);
-  update.nodes.push_back(tree2_6);
-  std::vector<AXEventNotificationDetails> events;
-  events.push_back(AXEventNotificationDetails());
-  AXEventNotificationDetails* event = &events[0];
-  event->event_type = ui::AX_EVENT_CHILDREN_CHANGED;
-  event->id = tree2_1.id;
-  manager->OnAccessibilityEvents(update, events);
+  std::vector<AXEventNotificationDetails> params;
+  params.push_back(AXEventNotificationDetails());
+  AXEventNotificationDetails* msg = &params[0];
+  msg->event_type = ui::AX_EVENT_CHILDREN_CHANGED;
+  msg->update.nodes.push_back(tree2_1);
+  msg->update.nodes.push_back(tree2_4);
+  msg->update.nodes.push_back(tree2_5);
+  msg->update.nodes.push_back(tree2_6);
+  msg->id = tree2_1.id;
+  manager->OnAccessibilityEvents(params);
 
   // There should be 4 objects now.
   EXPECT_EQ(4, CountedBrowserAccessibility::global_obj_count_);
@@ -1507,13 +1504,12 @@
   root2.id = 3;
   root2.role = ui::AX_ROLE_ROOT_WEB_AREA;
 
-  ui::AXTreeUpdate update;
-  update = MakeAXTreeUpdate(root2);
   std::vector<AXEventNotificationDetails> events2;
   events2.push_back(AXEventNotificationDetails());
+  events2[0].update = MakeAXTreeUpdate(root2);
   events2[0].id = -1;
   events2[0].event_type = ui::AX_EVENT_NONE;
-  manager->OnAccessibilityEvents(update, events2);
+  manager->OnAccessibilityEvents(events2);
 
   // Make sure that the focused node was updated to the new root and
   // that this doesn't crash.
@@ -1555,13 +1551,13 @@
   root2.role = ui::AX_ROLE_ROOT_WEB_AREA;
 
   // Make an update the explicitly clears the previous root.
-  ui::AXTreeUpdate update = MakeAXTreeUpdate(root2);
-  update.node_id_to_clear = 1;
   std::vector<AXEventNotificationDetails> events2;
   events2.push_back(AXEventNotificationDetails());
+  events2[0].update = MakeAXTreeUpdate(root2);
+  events2[0].update.node_id_to_clear = 1;
   events2[0].id = -1;
   events2[0].event_type = ui::AX_EVENT_NONE;
-  manager->OnAccessibilityEvents(update, events2);
+  manager->OnAccessibilityEvents(events2);
 
   // Make sure that the focused node was updated to the new root and
   // that this doesn't crash.

content/browser/accessibility/browser_accessibility_win_unittest.cc

diff --git a/content/browser/accessibility/browser_accessibility_win_unittest.cc b/content/browser/accessibility/browser_accessibility_win_unittest.cc
index 0d6623f..cac0cf8 100644
--- a/content/browser/accessibility/browser_accessibility_win_unittest.cc
+++ b/content/browser/accessibility/browser_accessibility_win_unittest.cc
@@ -166,14 +166,13 @@
   text2.id = 2;
   text2.role = ui::AX_ROLE_STATIC_TEXT;
   text2.SetName("new text");
-  ui::AXTreeUpdate update;
-  update.nodes.push_back(text2);
   AXEventNotificationDetails param;
   param.event_type = ui::AX_EVENT_CHILDREN_CHANGED;
+  param.update.nodes.push_back(text2);
   param.id = text2.id;
   std::vector<AXEventNotificationDetails> events;
   events.push_back(param);
-  manager->OnAccessibilityEvents(update, events);
+  manager->OnAccessibilityEvents(events);
 
   // Query for the text IAccessible and verify that it now returns "new text"
   // as its value.
@@ -233,14 +232,13 @@
   // Notify the BrowserAccessibilityManager that the div node and its children
   // were removed and ensure that only one BrowserAccessibility instance exists.
   root.child_ids.clear();
-  ui::AXTreeUpdate update;
-  update.nodes.push_back(root);
   AXEventNotificationDetails param;
   param.event_type = ui::AX_EVENT_CHILDREN_CHANGED;
+  param.update.nodes.push_back(root);
   param.id = root.id;
   std::vector<AXEventNotificationDetails> events;
   events.push_back(param);
-  manager->OnAccessibilityEvents(update, events);
+  manager->OnAccessibilityEvents(events);
 
   // Delete the manager and test that all BrowserAccessibility instances are
   // deleted.
@@ -656,16 +654,15 @@
   tree1_2.role = ui::AX_ROLE_TEXT_FIELD;
 
   // Process a load complete.
-  ui::AXTreeUpdate update;
-  update.root_id = tree1_1.id;
-  update.nodes.push_back(tree1_1);
-  update.nodes.push_back(tree1_2);
-  std::vector<AXEventNotificationDetails> events;
-  events.push_back(AXEventNotificationDetails());
-  AXEventNotificationDetails* msg = &events[0];
+  std::vector<AXEventNotificationDetails> params;
+  params.push_back(AXEventNotificationDetails());
+  AXEventNotificationDetails* msg = &params[0];
   msg->event_type = ui::AX_EVENT_LOAD_COMPLETE;
+  msg->update.root_id = tree1_1.id;
+  msg->update.nodes.push_back(tree1_1);
+  msg->update.nodes.push_back(tree1_2);
   msg->id = tree1_1.id;
-  manager->OnAccessibilityEvents(update, events);
+  manager->OnAccessibilityEvents(params);
 
   // Save for later comparison.
   BrowserAccessibility* acc1_2 = manager->GetFromID(2);
@@ -687,13 +684,13 @@
   tree2_2.id = 3;
   tree2_2.role = ui::AX_ROLE_BUTTON;
 
-  update.nodes.clear();
-  update.nodes.push_back(tree2_1);
-  update.nodes.push_back(tree2_2);
+  msg->update.nodes.clear();
+  msg->update.nodes.push_back(tree2_1);
+  msg->update.nodes.push_back(tree2_2);
   msg->id = tree2_1.id;
 
   // Fire another load complete.
-  manager->OnAccessibilityEvents(update, events);
+  manager->OnAccessibilityEvents(params);
 
   BrowserAccessibility* acc2_2 = manager->GetFromID(3);
 
@@ -2384,13 +2381,12 @@
   // Try adding one more relation.
   std::vector<int32_t> labelledby_ids = {3};
   child1.AddIntListAttribute(ui::AX_ATTR_LABELLEDBY_IDS, labelledby_ids);
-  ui::AXTreeUpdate update;
-  update.nodes.push_back(child1);
   AXEventNotificationDetails event;
   event.event_type = ui::AX_EVENT_ARIA_ATTRIBUTE_CHANGED;
+  event.update.nodes.push_back(child1);
   event.id = child1.id;
   std::vector<AXEventNotificationDetails> events = {event};
-  manager->OnAccessibilityEvents(update, events);
+  manager->OnAccessibilityEvents(events);
 
   EXPECT_HRESULT_SUCCEEDED(ax_child1->GetCOM()->get_nRelations(&n_relations));
   EXPECT_EQ(2, n_relations);

content/browser/download/download_request_core.cc

diff --git a/content/browser/download/download_request_core.cc b/content/browser/download/download_request_core.cc
index 92a9491e..590c99f 100644
--- a/content/browser/download/download_request_core.cc
+++ b/content/browser/download/download_request_core.cc
@@ -24,6 +24,7 @@
 #include "content/browser/download/download_request_handle.h"
 #include "content/browser/download/download_stats.h"
 #include "content/browser/download/download_task_runner.h"
+#include "content/browser/download/download_utils.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/service_manager/service_manager_context.h"
 #include "content/public/browser/browser_thread.h"
@@ -437,29 +438,17 @@
     has_strong_validators =
         request()->response_headers()->HasStrongValidators();
   }
-  DownloadInterruptReason reason = HandleRequestStatus(
-      status, has_strong_validators);
 
-  if (status.error() == net::ERR_ABORTED) {
-    // ERR_ABORTED == something outside of the network
-    // stack cancelled the request.  There aren't that many things that
-    // could do this to a download request (whose lifetime is separated from
-    // the tab from which it came).  We map this to USER_CANCELLED as the
-    // case we know about (system suspend because of laptop close) corresponds
-    // to a user action.
-    // TODO(asanka): A lid close or other power event should result in an
-    // interruption that doesn't discard the partial state, unlike
-    // USER_CANCELLED. (https://crbug.com/166179)
-    if (net::IsCertStatusError(request()->ssl_info().cert_status)) {
-      reason = DOWNLOAD_INTERRUPT_REASON_SERVER_CERT_PROBLEM;
-    } else {
-      reason = DOWNLOAD_INTERRUPT_REASON_USER_CANCELED;
-    }
-  } else if (abort_reason_ != DOWNLOAD_INTERRUPT_REASON_NONE) {
-    // If a more specific interrupt reason was specified before the request
-    // was explicitly cancelled, then use it.
-    reason = abort_reason_;
+  net::Error error_code = net::OK;
+  if (!status.is_success()) {
+    error_code = static_cast<net::Error>(status.error());  // Normal case.
+    // Make sure that at least the fact of failure comes through.
+    if (error_code == net::OK)
+      error_code = net::ERR_FAILED;
   }
+  DownloadInterruptReason reason = HandleRequestCompletionStatus(
+      error_code, has_strong_validators, request()->ssl_info().cert_status,
+      abort_reason_);
 
   std::string accept_ranges;
   if (request()->response_headers()) {
@@ -536,40 +525,6 @@
 }
 
 // static
-DownloadInterruptReason DownloadRequestCore::HandleRequestStatus(
-    const net::URLRequestStatus& status, bool has_strong_validators) {
-  net::Error error_code = net::OK;
-  if (!status.is_success()) {
-    error_code = static_cast<net::Error>(status.error());  // Normal case.
-    // Make sure that at least the fact of failure comes through.
-    if (error_code == net::OK)
-      error_code = net::ERR_FAILED;
-  }
-
-  // ERR_CONTENT_LENGTH_MISMATCH can be caused by 1 of the following reasons:
-  // 1. Server or proxy closes the connection too early.
-  // 2. The content-length header is wrong.
-  // If the download has strong validators, we can interrupt the download
-  // and let it resume automatically. Otherwise, resuming the download will
-  // cause it to restart and the download may never complete if the error was
-  // caused by reason 2. As a result, downloads without strong validators are
-  // treated as completed here.
-  // TODO(qinmin): check the metrics from downloads with strong validators,
-  // and decide whether we should interrupt downloads without strong validators
-  // rather than complete them.
-  if (error_code == net::ERR_CONTENT_LENGTH_MISMATCH &&
-      !has_strong_validators) {
-    error_code = net::OK;
-    RecordDownloadCount(COMPLETED_WITH_CONTENT_LENGTH_MISMATCH_COUNT);
-  }
-
-  DownloadInterruptReason reason = ConvertNetErrorToInterruptReason(
-      error_code, DOWNLOAD_INTERRUPT_FROM_NETWORK);
-
-  return reason;
-}
-
-// static
 DownloadInterruptReason DownloadRequestCore::HandleSuccessfulServerResponse(
     const net::HttpResponseHeaders& http_headers,
     DownloadSaveInfo* save_info) {

content/browser/download/download_request_core.h

diff --git a/content/browser/download/download_request_core.h b/content/browser/download/download_request_core.h
index 95d3167..85208c6 100644
--- a/content/browser/download/download_request_core.h
+++ b/content/browser/download/download_request_core.h
@@ -115,9 +115,6 @@
   net::URLRequest* request() const { return request_; }
 
  private:
-  static DownloadInterruptReason HandleRequestStatus(
-      const net::URLRequestStatus& status, bool has_strong_validators);
-
   static DownloadInterruptReason HandleSuccessfulServerResponse(
       const net::HttpResponseHeaders& http_headers,
       DownloadSaveInfo* save_info);

content/browser/download/download_utils.cc

diff --git a/content/browser/download/download_utils.cc b/content/browser/download/download_utils.cc
new file mode 100644
index 0000000..b36171f2
--- /dev/null
+++ b/content/browser/download/download_utils.cc
@@ -0,0 +1,56 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/browser/download/download_utils.h"
+
+#include "content/browser/download/download_interrupt_reasons_impl.h"
+#include "content/browser/download/download_stats.h"
+
+namespace content {
+
+DownloadInterruptReason HandleRequestCompletionStatus(
+    net::Error error_code, bool has_strong_validators,
+    net::CertStatus cert_status, DownloadInterruptReason abort_reason) {
+  // ERR_CONTENT_LENGTH_MISMATCH can be caused by 1 of the following reasons:
+  // 1. Server or proxy closes the connection too early.
+  // 2. The content-length header is wrong.
+  // If the download has strong validators, we can interrupt the download
+  // and let it resume automatically. Otherwise, resuming the download will
+  // cause it to restart and the download may never complete if the error was
+  // caused by reason 2. As a result, downloads without strong validators are
+  // treated as completed here.
+  // TODO(qinmin): check the metrics from downloads with strong validators,
+  // and decide whether we should interrupt downloads without strong validators
+  // rather than complete them.
+  if (error_code == net::ERR_CONTENT_LENGTH_MISMATCH &&
+      !has_strong_validators) {
+    error_code = net::OK;
+    RecordDownloadCount(COMPLETED_WITH_CONTENT_LENGTH_MISMATCH_COUNT);
+  }
+
+  if (error_code == net::ERR_ABORTED) {
+    // ERR_ABORTED == something outside of the network
+    // stack cancelled the request.  There aren't that many things that
+    // could do this to a download request (whose lifetime is separated from
+    // the tab from which it came).  We map this to USER_CANCELLED as the
+    // case we know about (system suspend because of laptop close) corresponds
+    // to a user action.
+    // TODO(asanka): A lid close or other power event should result in an
+    // interruption that doesn't discard the partial state, unlike
+     // USER_CANCELLED. (https://crbug.com/166179)
+    if (net::IsCertStatusError(cert_status))
+      return DOWNLOAD_INTERRUPT_REASON_SERVER_CERT_PROBLEM;
+    else
+      return DOWNLOAD_INTERRUPT_REASON_USER_CANCELED;
+  } else if (abort_reason != DOWNLOAD_INTERRUPT_REASON_NONE) {
+    // If a more specific interrupt reason was specified before the request
+    // was explicitly cancelled, then use it.
+    return abort_reason;
+  }
+
+  return ConvertNetErrorToInterruptReason(
+      error_code, DOWNLOAD_INTERRUPT_FROM_NETWORK);
+}
+
+}  // namespace content

content/browser/download/download_utils.h

diff --git a/content/browser/download/download_utils.h b/content/browser/download/download_utils.h
new file mode 100644
index 0000000..e94f030
--- /dev/null
+++ b/content/browser/download/download_utils.h
@@ -0,0 +1,22 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_UTILS_H_
+#define CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_UTILS_H_
+
+#include "content/public/browser/download_interrupt_reasons.h"
+#include "net/base/net_errors.h"
+#include "net/cert/cert_status_flags.h"
+
+namespace content {
+
+// Handle the url request completion status and return the interrupt reasons.
+// |cert_status| is ignored if error_code is not net::ERR_ABORTED.
+DownloadInterruptReason CONTENT_EXPORT HandleRequestCompletionStatus(
+    net::Error error_code, bool has_strong_validators,
+    net::CertStatus cert_status, DownloadInterruptReason abort_reason);
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_UTILS_H_

content/browser/frame_host/render_frame_host_delegate.h

diff --git a/content/browser/frame_host/render_frame_host_delegate.h b/content/browser/frame_host/render_frame_host_delegate.h
index 6b99397..83b6ca0 100644
--- a/content/browser/frame_host/render_frame_host_delegate.h
+++ b/content/browser/frame_host/render_frame_host_delegate.h
@@ -21,8 +21,6 @@
 #include "mojo/public/cpp/bindings/scoped_interface_endpoint_handle.h"
 #include "net/http/http_response_headers.h"
 #include "services/device/public/interfaces/wake_lock.mojom.h"
-#include "ui/accessibility/ax_tree_id_registry.h"
-#include "ui/accessibility/ax_tree_update.h"
 #include "ui/base/window_open_disposition.h"
 
 #if defined(OS_WIN)
@@ -186,12 +184,9 @@
   // Called when accessibility events or location changes are received
   // from a render frame, when the accessibility mode has the
   // ui::AXMode::kWebContents flag set.
-  virtual void AccessibilityEventsReceived(
-      ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
-      const ui::AXTreeUpdate& update,
-      const std::vector<AXEventNotificationDetails>& events) {}
+  virtual void AccessibilityEventReceived(
+      const std::vector<AXEventNotificationDetails>& details) {}
   virtual void AccessibilityLocationChangesReceived(
-      ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
       const std::vector<AXLocationChangeNotificationDetails>& details) {}
 
   // Find a guest RenderFrameHost by its parent |render_frame_host| and

content/browser/frame_host/render_frame_host_impl.cc

diff --git a/content/browser/frame_host/render_frame_host_impl.cc b/content/browser/frame_host/render_frame_host_impl.cc
index 2bb1474..c69cae8 100644
--- a/content/browser/frame_host/render_frame_host_impl.cc
+++ b/content/browser/frame_host/render_frame_host_impl.cc
@@ -2361,10 +2361,8 @@
 }
 
 void RenderFrameHostImpl::OnAccessibilityEvents(
-    const AXContentTreeUpdate& content_update,
     const std::vector<AccessibilityHostMsg_EventParams>& params,
-    int reset_token,
-    int ack_token) {
+    int reset_token, int ack_token) {
   // Don't process this IPC if either we're waiting on a reset and this
   // IPC doesn't have the matching token ID, or if we're not waiting on a
   // reset but this message includes a reset token.
@@ -2380,50 +2378,58 @@
     if (accessibility_mode.has_mode(ui::AXMode::kNativeAPIs))
       GetOrCreateBrowserAccessibilityManager();
 
-    ui::AXTreeUpdate update;
-    AXContentTreeUpdateToAXTreeUpdate(content_update, &update);
-
-    std::vector<AXEventNotificationDetails> events;
-    events.reserve(params.size());
+    std::vector<AXEventNotificationDetails> details;
+    details.reserve(params.size());
     for (size_t i = 0; i < params.size(); ++i) {
       const AccessibilityHostMsg_EventParams& param = params[i];
-      AXEventNotificationDetails event_detail;
-      event_detail.event_type = param.event_type;
-      event_detail.id = param.id;
-      event_detail.event_from = param.event_from;
-      events.push_back(event_detail);
+      AXEventNotificationDetails detail;
+      detail.event_type = param.event_type;
+      detail.id = param.id;
+      detail.ax_tree_id = GetAXTreeID();
+      detail.event_from = param.event_from;
+      if (param.update.has_tree_data) {
+        detail.update.has_tree_data = true;
+        ax_content_tree_data_ = param.update.tree_data;
+        AXContentTreeDataToAXTreeData(&detail.update.tree_data);
+      }
+      detail.update.root_id = param.update.root_id;
+      detail.update.node_id_to_clear = param.update.node_id_to_clear;
+      detail.update.nodes.resize(param.update.nodes.size());
+      for (size_t i = 0; i < param.update.nodes.size(); ++i) {
+        AXContentNodeDataToAXNodeData(param.update.nodes[i],
+                                      &detail.update.nodes[i]);
+      }
+      details.push_back(detail);
     }
 
     if (accessibility_mode.has_mode(ui::AXMode::kNativeAPIs)) {
       if (browser_accessibility_manager_)
-        browser_accessibility_manager_->OnAccessibilityEvents(update, events);
+        browser_accessibility_manager_->OnAccessibilityEvents(details);
     }
 
-    delegate_->AccessibilityEventsReceived(GetAXTreeID(), update, events);
+    delegate_->AccessibilityEventReceived(details);
 
     // For testing only.
     if (!accessibility_testing_callback_.is_null()) {
-      if (!ax_tree_for_testing_) {
-        if (browser_accessibility_manager_) {
-          ax_tree_for_testing_.reset(new ui::AXTree(
-              browser_accessibility_manager_->SnapshotAXTreeForTesting()));
-        } else {
-          ax_tree_for_testing_.reset(new ui::AXTree());
-          CHECK(ax_tree_for_testing_->Unserialize(update))
-              << ax_tree_for_testing_->error();
-        }
-      } else {
-        CHECK(ax_tree_for_testing_->Unserialize(update))
-            << ax_tree_for_testing_->error();
-      }
-
-      for (size_t i = 0; i < events.size(); i++) {
-        const AXEventNotificationDetails& event_detail = events[i];
-        if (static_cast<int>(event_detail.event_type) < 0)
+      for (size_t i = 0; i < details.size(); i++) {
+        const AXEventNotificationDetails& detail = details[i];
+        if (static_cast<int>(detail.event_type) < 0)
           continue;
 
-        accessibility_testing_callback_.Run(this, event_detail.event_type,
-                                            event_detail.id);
+        if (!ax_tree_for_testing_) {
+          if (browser_accessibility_manager_) {
+            ax_tree_for_testing_.reset(new ui::AXTree(
+                browser_accessibility_manager_->SnapshotAXTreeForTesting()));
+          } else {
+            ax_tree_for_testing_.reset(new ui::AXTree());
+            CHECK(ax_tree_for_testing_->Unserialize(detail.update))
+                << ax_tree_for_testing_->error();
+          }
+        } else {
+          CHECK(ax_tree_for_testing_->Unserialize(detail.update))
+              << ax_tree_for_testing_->error();
+        }
+        accessibility_testing_callback_.Run(this, detail.event_type, detail.id);
       }
     }
   }
@@ -2455,10 +2461,11 @@
       const AccessibilityHostMsg_LocationChangeParams& param = params[i];
       AXLocationChangeNotificationDetails detail;
       detail.id = param.id;
+      detail.ax_tree_id = GetAXTreeID();
       detail.new_location = param.new_location;
       details.push_back(detail);
     }
-    delegate_->AccessibilityLocationChangesReceived(GetAXTreeID(), details);
+    delegate_->AccessibilityLocationChangesReceived(details);
   }
 }
 
@@ -3592,16 +3599,18 @@
     return;
   }
 
-  ui::AXTreeUpdate update;
-  update.has_tree_data = true;
-  AXContentTreeDataToAXTreeData(&update.tree_data);
-
-  std::vector<AXEventNotificationDetails> empty_events;
+  std::vector<AXEventNotificationDetails> details;
+  details.reserve(1U);
+  AXEventNotificationDetails detail;
+  detail.ax_tree_id = GetAXTreeID();
+  detail.update.has_tree_data = true;
+  AXContentTreeDataToAXTreeData(&detail.update.tree_data);
+  details.push_back(detail);
 
   if (browser_accessibility_manager_)
-    browser_accessibility_manager_->OnAccessibilityEvents(update, empty_events);
+    browser_accessibility_manager_->OnAccessibilityEvents(details);
 
-  delegate_->AccessibilityEventsReceived(GetAXTreeID(), update, empty_events);
+  delegate_->AccessibilityEventReceived(details);
 }
 
 void RenderFrameHostImpl::SetTextTrackSettings(
@@ -3896,21 +3905,6 @@
   return guest->GetAXTreeID();
 }
 
-void RenderFrameHostImpl::AXContentTreeUpdateToAXTreeUpdate(
-    const AXContentTreeUpdate& src,
-    ui::AXTreeUpdate* dst) {
-  if (src.has_tree_data) {
-    dst->has_tree_data = true;
-    ax_content_tree_data_ = src.tree_data;
-    AXContentTreeDataToAXTreeData(&dst->tree_data);
-  }
-  dst->root_id = src.root_id;
-  dst->node_id_to_clear = src.node_id_to_clear;
-  dst->nodes.resize(src.nodes.size());
-  for (size_t i = 0; i < src.nodes.size(); ++i)
-    AXContentNodeDataToAXNodeData(src.nodes[i], &dst->nodes[i]);
-}
-
 void RenderFrameHostImpl::AXContentNodeDataToAXNodeData(
     const AXContentNodeData& src,
     ui::AXNodeData* dst) {

content/browser/frame_host/render_frame_host_impl.h

diff --git a/content/browser/frame_host/render_frame_host_impl.h b/content/browser/frame_host/render_frame_host_impl.h
index 3f961c5..4bfcaaf 100644
--- a/content/browser/frame_host/render_frame_host_impl.h
+++ b/content/browser/frame_host/render_frame_host_impl.h
@@ -772,7 +772,6 @@
   void OnAbortNavigation();
   void OnDispatchLoad();
   void OnAccessibilityEvents(
-      const AXContentTreeUpdate& update,
       const std::vector<AccessibilityHostMsg_EventParams>& params,
       int reset_token,
       int ack_token);
@@ -890,13 +889,13 @@
   ui::AXTreeIDRegistry::AXTreeID BrowserPluginInstanceIDToAXTreeID(
       int routing_id);
 
-  // Convert content-layer-specific subclasses of accessibility data structures
-  // to general-purpose accessibility data structures that can be shared
-  // outside of content.
-  void AXContentTreeUpdateToAXTreeUpdate(const AXContentTreeUpdate& src,
-                                         ui::AXTreeUpdate* dst);
+  // Convert the content-layer-specific AXContentNodeData to a general-purpose
+  // AXNodeData structure.
   void AXContentNodeDataToAXNodeData(const AXContentNodeData& src,
                                      ui::AXNodeData* dst);
+
+  // Convert the content-layer-specific AXContentTreeData to a general-purpose
+  // AXTreeData structure.
   void AXContentTreeDataToAXTreeData(ui::AXTreeData* dst);
 
   // Returns the RenderWidgetHostView used for accessibility. For subframes,

content/browser/renderer_host/offscreen_canvas_provider_impl_unittest.cc

diff --git a/content/browser/renderer_host/offscreen_canvas_provider_impl_unittest.cc b/content/browser/renderer_host/offscreen_canvas_provider_impl_unittest.cc
index ed5d7440..82d7aaa 100644
--- a/content/browser/renderer_host/offscreen_canvas_provider_impl_unittest.cc
+++ b/content/browser/renderer_host/offscreen_canvas_provider_impl_unittest.cc
@@ -206,8 +206,9 @@
 
   // Renderer submits a CompositorFrame with |local_id|.
   const viz::LocalSurfaceId local_id(1, base::UnguessableToken::Create());
-  compositor_frame_sink->SubmitCompositorFrame(local_id, MakeCompositorFrame(),
-                                               nullptr);
+  compositor_frame_sink->SubmitCompositorFrame(
+      local_id, MakeCompositorFrame(), nullptr,
+      base::TimeTicks::Now().since_origin().InMicroseconds());
 
   RunUntilIdle();
 

content/browser/renderer_host/render_widget_host_impl.cc

diff --git a/content/browser/renderer_host/render_widget_host_impl.cc b/content/browser/renderer_host/render_widget_host_impl.cc
index 42ae340..c7bde34 100644
--- a/content/browser/renderer_host/render_widget_host_impl.cc
+++ b/content/browser/renderer_host/render_widget_host_impl.cc
@@ -2574,8 +2574,22 @@
 void RenderWidgetHostImpl::SubmitCompositorFrame(
     const viz::LocalSurfaceId& local_surface_id,
     cc::CompositorFrame frame,
-    viz::mojom::HitTestRegionListPtr hit_test_region_list) {
+    viz::mojom::HitTestRegionListPtr hit_test_region_list,
+    uint64_t submit_time) {
   // TODO(gklassen): Route hit-test data to appropriate HitTestAggregator.
+  TRACE_EVENT_FLOW_END0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+                        "SubmitCompositorFrame", local_surface_id.local_id());
+  bool tracing_enabled;
+  TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+                                     &tracing_enabled);
+  if (tracing_enabled) {
+    base::TimeDelta elapsed = base::TimeTicks::Now().since_origin() -
+                              base::TimeDelta::FromMicroseconds(submit_time);
+    TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+                         "SubmitCompositorFrame::TimeElapsed",
+                         TRACE_EVENT_SCOPE_THREAD,
+                         "elapsed time:", elapsed.InMicroseconds());
+  }
   auto new_surface_properties =
       RenderWidgetSurfaceProperties::FromCompositorFrame(frame);
 
@@ -2711,8 +2725,13 @@
 void RenderWidgetHostImpl::DidAllocateSharedBitmap(uint32_t sequence_number) {
   if (saved_frame_.local_surface_id.is_valid() &&
       sequence_number >= saved_frame_.max_shared_bitmap_sequence_number) {
-    SubmitCompositorFrame(saved_frame_.local_surface_id,
-                          std::move(saved_frame_.frame), nullptr);
+    bool tracing_enabled;
+    TRACE_EVENT_CATEGORY_GROUP_ENABLED(
+        TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"), &tracing_enabled);
+    SubmitCompositorFrame(
+        saved_frame_.local_surface_id, std::move(saved_frame_.frame), nullptr,
+        tracing_enabled ? base::TimeTicks::Now().since_origin().InMicroseconds()
+                        : 0);
     saved_frame_.local_surface_id = viz::LocalSurfaceId();
     compositor_frame_sink_binding_.ResumeIncomingMethodCallProcessing();
     TRACE_EVENT_ASYNC_END0("renderer_host", "PauseCompositorFrameSink", this);

content/browser/renderer_host/render_widget_host_impl.h

diff --git a/content/browser/renderer_host/render_widget_host_impl.h b/content/browser/renderer_host/render_widget_host_impl.h
index b7b3e81..acf2bf5 100644
--- a/content/browser/renderer_host/render_widget_host_impl.h
+++ b/content/browser/renderer_host/render_widget_host_impl.h
@@ -585,7 +585,8 @@
   void SubmitCompositorFrame(
       const viz::LocalSurfaceId& local_surface_id,
       cc::CompositorFrame frame,
-      viz::mojom::HitTestRegionListPtr hit_test_region_list) override;
+      viz::mojom::HitTestRegionListPtr hit_test_region_list,
+      uint64_t submit_time) override;
   void DidNotProduceFrame(const viz::BeginFrameAck& ack) override;
 
   // Signals that a frame with token |frame_token| was finished processing. If

content/browser/renderer_host/render_widget_host_unittest.cc

diff --git a/content/browser/renderer_host/render_widget_host_unittest.cc b/content/browser/renderer_host/render_widget_host_unittest.cc
index 55345c93..50b045a 100644
--- a/content/browser/renderer_host/render_widget_host_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_unittest.cc
@@ -1453,7 +1453,7 @@
   host_->StartNewContentRenderingTimeout(5);
   cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
   frame.metadata.content_source_id = 5;
-  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr, 0);
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
       TimeDelta::FromMicroseconds(20));
@@ -1467,7 +1467,7 @@
   host_->StartNewContentRenderingTimeout(10);
   frame = MakeCompositorFrame(1.f, frame_size);
   frame.metadata.content_source_id = 9;
-  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr, 0);
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
       TimeDelta::FromMicroseconds(20));
@@ -1480,7 +1480,7 @@
   // attempt to start the timer. The timer shouldn't fire.
   frame = MakeCompositorFrame(1.f, frame_size);
   frame.metadata.content_source_id = 7;
-  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr, 0);
   host_->StartNewContentRenderingTimeout(7);
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
@@ -1516,7 +1516,8 @@
     cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
     frame.metadata.begin_frame_ack = viz::BeginFrameAck(0, 1, true);
     frame.metadata.content_source_id = 99;
-    host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+    host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr,
+                                 0);
     EXPECT_FALSE(
         static_cast<TestView*>(host_->GetView())->did_swap_compositor_frame());
     static_cast<TestView*>(host_->GetView())->reset_did_swap_compositor_frame();
@@ -1526,7 +1527,8 @@
     // Test with a valid content ID as a control.
     cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
     frame.metadata.content_source_id = 100;
-    host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+    host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr,
+                                 0);
     EXPECT_TRUE(
         static_cast<TestView*>(host_->GetView())->did_swap_compositor_frame());
     static_cast<TestView*>(host_->GetView())->reset_did_swap_compositor_frame();
@@ -1538,7 +1540,8 @@
     // the corresponding DidCommitProvisionalLoad (it's a race).
     cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
     frame.metadata.content_source_id = 101;
-    host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+    host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr,
+                                 0);
     EXPECT_TRUE(
         static_cast<TestView*>(host_->GetView())->did_swap_compositor_frame());
   }
@@ -2052,7 +2055,7 @@
 
   cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
   frame.metadata.frame_token = frame_token;
-  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr, 0);
   EXPECT_EQ(0u, host_->queued_messages_.size());
   EXPECT_EQ(1u, host_->processed_frame_messages_count());
 }
@@ -2072,7 +2075,7 @@
 
   cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
   frame.metadata.frame_token = frame_token;
-  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr, 0);
   EXPECT_EQ(0u, host_->queued_messages_.size());
   EXPECT_EQ(0u, host_->processed_frame_messages_count());
 
@@ -2110,13 +2113,13 @@
 
   cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
   frame.metadata.frame_token = frame_token1;
-  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr, 0);
   EXPECT_EQ(1u, host_->queued_messages_.size());
   EXPECT_EQ(1u, host_->processed_frame_messages_count());
 
   frame = MakeCompositorFrame(1.f, frame_size);
   frame.metadata.frame_token = frame_token2;
-  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr, 0);
   EXPECT_EQ(0u, host_->queued_messages_.size());
   EXPECT_EQ(2u, host_->processed_frame_messages_count());
 }
@@ -2139,13 +2142,13 @@
 
   cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
   frame.metadata.frame_token = frame_token1;
-  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr, 0);
   EXPECT_EQ(0u, host_->queued_messages_.size());
   EXPECT_EQ(0u, host_->processed_frame_messages_count());
 
   frame = MakeCompositorFrame(1.f, frame_size);
   frame.metadata.frame_token = frame_token2;
-  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr, 0);
   EXPECT_EQ(0u, host_->queued_messages_.size());
   EXPECT_EQ(0u, host_->processed_frame_messages_count());
 
@@ -2188,7 +2191,7 @@
 
   cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
   frame.metadata.frame_token = frame_token2;
-  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr, 0);
   EXPECT_EQ(0u, host_->queued_messages_.size());
   EXPECT_EQ(2u, host_->processed_frame_messages_count());
 }
@@ -2223,7 +2226,7 @@
 
   cc::CompositorFrame frame = MakeCompositorFrame(1.f, frame_size);
   frame.metadata.frame_token = frame_token2;
-  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr, 0);
   EXPECT_EQ(0u, host_->queued_messages_.size());
   EXPECT_EQ(0u, host_->processed_frame_messages_count());
 
@@ -2239,7 +2242,7 @@
 
   frame = MakeCompositorFrame(1.f, frame_size);
   frame.metadata.frame_token = frame_token3;
-  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr);
+  host_->SubmitCompositorFrame(local_surface_id, std::move(frame), nullptr, 0);
   EXPECT_EQ(0u, host_->queued_messages_.size());
   EXPECT_EQ(1u, host_->processed_frame_messages_count());
 }

content/browser/web_contents/web_contents_impl.cc

diff --git a/content/browser/web_contents/web_contents_impl.cc b/content/browser/web_contents/web_contents_impl.cc
index f5d3d5f..4442c8f7 100644
--- a/content/browser/web_contents/web_contents_impl.cc
+++ b/content/browser/web_contents/web_contents_impl.cc
@@ -2658,19 +2658,16 @@
   return accessibility_mode_;
 }
 
-void WebContentsImpl::AccessibilityEventsReceived(
-    ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
-    const ui::AXTreeUpdate& update,
-    const std::vector<AXEventNotificationDetails>& events) {
+void WebContentsImpl::AccessibilityEventReceived(
+    const std::vector<AXEventNotificationDetails>& details) {
   for (auto& observer : observers_)
-    observer.AccessibilityEventsReceived(ax_tree_id, update, events);
+    observer.AccessibilityEventReceived(details);
 }
 
 void WebContentsImpl::AccessibilityLocationChangesReceived(
-    ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
     const std::vector<AXLocationChangeNotificationDetails>& details) {
   for (auto& observer : observers_)
-    observer.AccessibilityLocationChangesReceived(ax_tree_id, details);
+    observer.AccessibilityLocationChangesReceived(details);
 }
 
 RenderFrameHost* WebContentsImpl::GetGuestByInstanceID(

content/browser/web_contents/web_contents_impl.h

diff --git a/content/browser/web_contents/web_contents_impl.h b/content/browser/web_contents/web_contents_impl.h
index 21d183b..bf33494 100644
--- a/content/browser/web_contents/web_contents_impl.h
+++ b/content/browser/web_contents/web_contents_impl.h
@@ -523,12 +523,9 @@
   WebContents* GetAsWebContents() override;
   bool IsNeverVisible() override;
   ui::AXMode GetAccessibilityMode() const override;
-  void AccessibilityEventsReceived(
-      ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
-      const ui::AXTreeUpdate& update,
-      const std::vector<AXEventNotificationDetails>& events) override;
+  void AccessibilityEventReceived(
+      const std::vector<AXEventNotificationDetails>& details) override;
   void AccessibilityLocationChangesReceived(
-      ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
       const std::vector<AXLocationChangeNotificationDetails>& details) override;
   RenderFrameHost* GetGuestByInstanceID(
       RenderFrameHost* render_frame_host,

content/common/accessibility_messages.h

diff --git a/content/common/accessibility_messages.h b/content/common/accessibility_messages.h
index 7588590f..f2cbf5a 100644
--- a/content/common/accessibility_messages.h
+++ b/content/common/accessibility_messages.h
@@ -90,6 +90,9 @@
 IPC_STRUCT_TRAITS_END()
 
 IPC_STRUCT_BEGIN(AccessibilityHostMsg_EventParams)
+  // The tree update.
+  IPC_STRUCT_MEMBER(content::AXContentTreeUpdate, update)
+
   // Type of event.
   IPC_STRUCT_MEMBER(ui::AXEvent, event_type)
 
@@ -177,15 +180,15 @@
 // Sent to notify the browser about renderer accessibility events.
 // The browser responds with a AccessibilityMsg_Events_ACK with the same
 // ack_token.
-// The parameter |reset_token| is set if this IPC was sent in response
+// The second parameter, reset_token, is set if this IPC was sent in response
 // to a reset request from the browser. When the browser requests a reset,
 // it ignores incoming IPCs until it sees one with the correct reset token.
 // Any other time, it ignores IPCs with a reset token.
-IPC_MESSAGE_ROUTED4(AccessibilityHostMsg_Events,
-                    content::AXContentTreeUpdate /* update */,
-                    std::vector<AccessibilityHostMsg_EventParams> /* events */,
-                    int /* reset_token */,
-                    int /* ack_token */)
+IPC_MESSAGE_ROUTED3(
+    AccessibilityHostMsg_Events,
+    std::vector<AccessibilityHostMsg_EventParams> /* events */,
+    int /* reset_token */,
+    int /* ack_token */)
 
 // Sent to update the browser of the location of accessibility objects.
 IPC_MESSAGE_ROUTED1(

content/network/url_loader_impl.cc

diff --git a/content/network/url_loader_impl.cc b/content/network/url_loader_impl.cc
index 1074715e..c21d17b 100644
--- a/content/network/url_loader_impl.cc
+++ b/content/network/url_loader_impl.cc
@@ -217,6 +217,7 @@
 void URLLoaderImpl::FollowRedirect() {
   if (!url_request_) {
     NotifyCompleted(net::ERR_UNEXPECTED);
+    // |this| may have been deleted.
     return;
   }
 
@@ -251,6 +252,7 @@
 
   if (net_error != net::OK) {
     NotifyCompleted(net_error);
+    // |this| may have been deleted.
     return;
   }
 
@@ -323,17 +325,19 @@
   } else if (url_request_->status().is_success() && bytes_read > 0) {
     DidRead(static_cast<uint32_t>(bytes_read), true);
   } else {
-    NotifyCompleted(net::OK);
     writable_handle_watcher_.Cancel();
-    pending_write_->Complete(pending_write_buffer_offset_);
-    pending_write_ = nullptr;  // This closes the data pipe.
-    DeleteIfNeeded();
+    CompletePendingWrite();
+
+    // Close body pipe.
+    response_body_stream_.reset();
+
+    NotifyCompleted(url_request_->status().ToNetError());
+    // |this| may have been deleted.
     return;
   }
 }
 
 void URLLoaderImpl::DidRead(uint32_t num_bytes, bool completed_synchronously) {
-  total_written_bytes_ += num_bytes;
   pending_write_buffer_offset_ += num_bytes;
   DCHECK(url_request_->status().is_success());
   bool complete_read = true;
@@ -356,9 +360,7 @@
   }
 
   if (complete_read) {
-    response_body_stream_ =
-        pending_write_->Complete(pending_write_buffer_offset_);
-    pending_write_ = nullptr;
+    CompletePendingWrite();
   }
   if (completed_synchronously) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ -375,8 +377,14 @@
 
   if (!url_request->status().is_success()) {
     writable_handle_watcher_.Cancel();
-    pending_write_ = nullptr;  // This closes the data pipe.
-    DeleteIfNeeded();
+    CompletePendingWrite();
+
+    // This closes the data pipe.
+    // TODO(mmenke): Should NotifyCompleted close the data pipe itself instead?
+    response_body_stream_.reset();
+
+    NotifyCompleted(url_request_->status().ToNetError());
+    // |this| may have been deleted.
     return;
   }
 
@@ -450,4 +458,11 @@
   response_ = nullptr;
 }
 
+void URLLoaderImpl::CompletePendingWrite() {
+  response_body_stream_ =
+      pending_write_->Complete(pending_write_buffer_offset_);
+  pending_write_ = nullptr;
+  total_written_bytes_ += pending_write_buffer_offset_;
+}
+
 }  // namespace content

content/network/url_loader_impl.h

diff --git a/content/network/url_loader_impl.h b/content/network/url_loader_impl.h
index 914e29f..a349be2 100644
--- a/content/network/url_loader_impl.h
+++ b/content/network/url_loader_impl.h
@@ -62,6 +62,7 @@
   void OnResponseBodyStreamReady(MojoResult result);
   void DeleteIfNeeded();
   void SendResponseToClient();
+  void CompletePendingWrite();
 
   NetworkContext* context_;
   int32_t options_;

content/network/url_loader_unittest.cc

diff --git a/content/network/url_loader_unittest.cc b/content/network/url_loader_unittest.cc
index 03c9872..022e0263 100644
--- a/content/network/url_loader_unittest.cc
+++ b/content/network/url_loader_unittest.cc
@@ -21,6 +21,7 @@
 #include "net/base/io_buffer.h"
 #include "net/base/mime_sniffer.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
+#include "net/test/url_request/url_request_failed_job.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_filter.h"
@@ -124,8 +125,12 @@
   URLLoaderImplTest()
       : scoped_task_environment_(
             base::test::ScopedTaskEnvironment::MainThreadType::IO),
-        context_(NetworkContext::CreateForTesting()) {}
-  ~URLLoaderImplTest() override {}
+        context_(NetworkContext::CreateForTesting()) {
+    net::URLRequestFailedJob::AddUrlHandler();
+  }
+  ~URLLoaderImplTest() override {
+    net::URLRequestFilter::GetInstance()->ClearHandlers();
+  }
 
   void SetUp() override {
     test_server_.AddDefaultHandlers(
@@ -134,6 +139,20 @@
   }
 
   void Load(const GURL& url) {
+    EXPECT_EQ(net::OK, LoadWithError(url, nullptr, 0));
+  }
+
+  // Attempts to load |url| and returns the resulting error code. If |data| is
+  // non-NULL, also attempts to read a response body of |expected_body_size|.
+  // The advantage of using |data| instead of calling ReadData() after
+  // LoadWithError is that it will load the response body before the URLLoader
+  // is destroyed, so pipes may still be open.
+  //
+  // TODO(mmenke): Come up with a better test fixture.
+  int LoadWithError(const GURL& url,
+                    std::string* data,
+                    size_t expected_body_size) {
+    DCHECK(!ran_);
     mojom::URLLoaderPtr loader;
 
     ResourceRequest request =
@@ -149,9 +168,13 @@
                               TRAFFIC_ANNOTATION_FOR_TESTS);
 
     client_.RunUntilComplete();
-    EXPECT_EQ(net::OK, client_.completion_status().error_code);
     DCHECK(!ran_);
     ran_ = true;
+
+    if (data)
+      *data = ReadData(expected_body_size);
+
+    return client_.completion_status().error_code;
   }
 
   void LoadAndCompareFile(const std::string& path) {
@@ -167,6 +190,19 @@
 
     Load(test_server()->GetURL(std::string("/") + path));
     EXPECT_EQ(expected, ReadData(expected.size()));
+    // The file isn't compressed, so both encoded and decoded body lengths
+    // should match the read body length.
+    EXPECT_EQ(
+        expected.size(),
+        static_cast<size_t>(client()->completion_status().decoded_body_length));
+    EXPECT_EQ(
+        expected.size(),
+        static_cast<size_t>(client()->completion_status().encoded_body_length));
+    // Over the wire length should include headers, so should be longer.
+    // TODO(mmenke): Worth adding better tests for encoded_data_length?
+    EXPECT_LT(
+        expected.size(),
+        static_cast<size_t>(client()->completion_status().encoded_data_length));
   }
 
   void LoadPackets(std::list<std::string> packets) {
@@ -188,7 +224,10 @@
       packets.push_back(second);
     LoadPackets(std::move(packets));
     std::string expected = first + second;
-    CHECK_EQ(expected, ReadData(expected.size()));
+    EXPECT_EQ(expected, ReadData(expected.size()));
+    EXPECT_EQ(
+        expected.size(),
+        static_cast<size_t>(client()->completion_status().decoded_body_length));
   }
 
   net::EmbeddedTestServer* test_server() { return &test_server_; }
@@ -233,6 +272,11 @@
              MOJO_RESULT_OK);
     CHECK_EQ(num_bytes, static_cast<uint32_t>(size));
 
+    // No more data should remain on the pipe.
+    CHECK_EQ(MojoReadData(consumer, buffer.data(), &num_bytes,
+                          MOJO_READ_DATA_FLAG_ALL_OR_NONE),
+             MOJO_RESULT_FAILED_PRECONDITION);
+
     return std::string(buffer.data(), buffer.size());
   }
 
@@ -282,6 +326,45 @@
   ASSERT_FALSE(!!ssl_info());
 }
 
+// Test decoded_body_length / encoded_body_length when they're different.
+TEST_F(URLLoaderImplTest, GzipTest) {
+  Load(test_server()->GetURL("/gzip-body?Body"));
+  EXPECT_EQ("Body", ReadData(4));
+  // Deflating a 4-byte string should result in a longer string - main thing to
+  // check here, though, is that the two lengths are of different.
+  EXPECT_LT(client()->completion_status().decoded_body_length,
+            client()->completion_status().encoded_body_length);
+  // Over the wire length should include headers, so should be longer.
+  EXPECT_LT(client()->completion_status().encoded_body_length,
+            client()->completion_status().encoded_data_length);
+}
+
+TEST_F(URLLoaderImplTest, ErrorBeforeHeaders) {
+  EXPECT_EQ(net::ERR_EMPTY_RESPONSE,
+            LoadWithError(test_server()->GetURL("/close-socket"), nullptr, 0));
+  EXPECT_FALSE(client()->response_body().is_valid());
+}
+
+TEST_F(URLLoaderImplTest, SyncErrorWhileReadingBody) {
+  std::string body;
+  EXPECT_EQ(
+      net::ERR_FAILED,
+      LoadWithError(net::URLRequestFailedJob::GetMockHttpUrlWithFailurePhase(
+                        net::URLRequestFailedJob::READ_SYNC, net::ERR_FAILED),
+                    &body, 0));
+  EXPECT_EQ("", body);
+}
+
+TEST_F(URLLoaderImplTest, AsyncErrorWhileReadingBody) {
+  std::string body;
+  EXPECT_EQ(
+      net::ERR_FAILED,
+      LoadWithError(net::URLRequestFailedJob::GetMockHttpUrlWithFailurePhase(
+                        net::URLRequestFailedJob::READ_ASYNC, net::ERR_FAILED),
+                    &body, 0));
+  EXPECT_EQ("", body);
+}
+
 TEST_F(URLLoaderImplTest, DestroyContextWithLiveRequest) {
   GURL url = test_server()->GetURL("/hung-after-headers");
   ResourceRequest request =

content/public/browser/ax_event_notification_details.cc

diff --git a/content/public/browser/ax_event_notification_details.cc b/content/public/browser/ax_event_notification_details.cc
index a40eceed..c8e0c95 100644
--- a/content/public/browser/ax_event_notification_details.cc
+++ b/content/public/browser/ax_event_notification_details.cc
@@ -9,6 +9,7 @@
 AXEventNotificationDetails::AXEventNotificationDetails()
     : event_type(ui::AX_EVENT_NONE),
       id(-1),
+      ax_tree_id(-1),
       event_from(ui::AX_EVENT_FROM_NONE) {}
 
 AXEventNotificationDetails::AXEventNotificationDetails(
@@ -17,7 +18,9 @@
 AXEventNotificationDetails::~AXEventNotificationDetails() {}
 
 AXLocationChangeNotificationDetails::AXLocationChangeNotificationDetails()
-    : id(-1) {}
+    : id(-1),
+      ax_tree_id(-1) {
+}
 
 AXLocationChangeNotificationDetails::AXLocationChangeNotificationDetails(
     const AXLocationChangeNotificationDetails& other) = default;

content/public/browser/ax_event_notification_details.h

diff --git a/content/public/browser/ax_event_notification_details.h b/content/public/browser/ax_event_notification_details.h
index 9626a11..174a449 100644
--- a/content/public/browser/ax_event_notification_details.h
+++ b/content/public/browser/ax_event_notification_details.h
@@ -16,15 +16,17 @@
 namespace content {
 
 // Use this object in conjunction with the
-// |WebContentsObserver::AccessibilityEventsReceived| method.
+// |WebContentsObserver::AccessibilityEventReceived| method.
 struct CONTENT_EXPORT AXEventNotificationDetails {
  public:
   AXEventNotificationDetails();
   AXEventNotificationDetails(const AXEventNotificationDetails& other);
   ~AXEventNotificationDetails();
 
+  ui::AXTreeUpdate update;
   ui::AXEvent event_type;
   int id;
+  int ax_tree_id;
   ui::AXEventFrom event_from;
 };
 
@@ -38,6 +40,7 @@
   ~AXLocationChangeNotificationDetails();
 
   int id;
+  int ax_tree_id;
   ui::AXRelativeBounds new_location;
 };
 

content/public/browser/web_contents_observer.h

diff --git a/content/public/browser/web_contents_observer.h b/content/public/browser/web_contents_observer.h
index f3512111..15d0a0a 100644
--- a/content/public/browser/web_contents_observer.h
+++ b/content/public/browser/web_contents_observer.h
@@ -22,8 +22,6 @@
 #include "services/service_manager/public/cpp/bind_source_info.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "third_party/skia/include/core/SkColor.h"
-#include "ui/accessibility/ax_tree_id_registry.h"
-#include "ui/accessibility/ax_tree_update.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/base/window_open_disposition.h"
 
@@ -397,12 +395,9 @@
   // Called when accessibility events or location changes are received
   // from a render frame, but only when the accessibility mode has the
   // ui::AXMode::kWebContents flag set.
-  virtual void AccessibilityEventsReceived(
-      ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
-      const ui::AXTreeUpdate& update,
-      const std::vector<AXEventNotificationDetails>& events) {}
+  virtual void AccessibilityEventReceived(
+      const std::vector<AXEventNotificationDetails>& details) {}
   virtual void AccessibilityLocationChangesReceived(
-      ui::AXTreeIDRegistry::AXTreeID ax_tree_id,
       const std::vector<AXLocationChangeNotificationDetails>& details) {}
 
   // Invoked when theme color is changed to |theme_color|.

content/public/test/render_view_test.cc

diff --git a/content/public/test/render_view_test.cc b/content/public/test/render_view_test.cc
index 0903d06..efef25a 100644
--- a/content/public/test/render_view_test.cc
+++ b/content/public/test/render_view_test.cc
@@ -527,10 +527,6 @@
   view_->GetWebView()->UpdateAllLifecyclePhases();
 }
 
-uint32_t RenderViewTest::GetNavigationIPCType() {
-  return FrameHostMsg_DidCommitProvisionalLoad::ID;
-}
-
 void RenderViewTest::Resize(gfx::Size new_size,
                             bool is_fullscreen_granted) {
   ResizeParams params;

content/public/test/render_view_test.h

diff --git a/content/public/test/render_view_test.h b/content/public/test/render_view_test.h
index 125bc47..cb8e112 100644
--- a/content/public/test/render_view_test.h
+++ b/content/public/test/render_view_test.h
@@ -147,9 +147,6 @@
   // Simulates a navigation with a type of reload to the given url.
   void Reload(const GURL& url);
 
-  // Returns the IPC message ID of the navigation message.
-  uint32_t GetNavigationIPCType();
-
   // Resize the view.
   void Resize(gfx::Size new_size, bool is_fullscreen);
 

content/renderer/accessibility/render_accessibility_impl.cc

diff --git a/content/renderer/accessibility/render_accessibility_impl.cc b/content/renderer/accessibility/render_accessibility_impl.cc
index 3ac27808..6a0e682 100644
--- a/content/renderer/accessibility/render_accessibility_impl.cc
+++ b/content/renderer/accessibility/render_accessibility_impl.cc
@@ -15,7 +15,6 @@
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "base/stl_util.h"
 #include "build/build_config.h"
 #include "content/common/accessibility_messages.h"
 #include "content/renderer/accessibility/blink_ax_enum_conversion.h"
@@ -381,11 +380,6 @@
   // If there's a layout complete message, we need to send location changes.
   bool had_layout_complete_messages = false;
 
-  // The changes to the accessibility tree will be captured here.
-  AXContentTreeUpdate update;
-  std::set<int32_t> updated_nodes;
-  size_t update_size = 0;
-
   // Loop over each event and generate an updated event message.
   for (size_t i = 0; i < src_events.size(); ++i) {
     AccessibilityHostMsg_EventParams& event = src_events[i];
@@ -414,47 +408,35 @@
     event_msg.event_type = event.event_type;
     event_msg.id = event.id;
     event_msg.event_from = event.event_from;
-
-    // Serialize |obj| and any other nodes related to |obj| that need to
-    // be sent over, but not if |update| already includes |obj|.
-    if (!base::ContainsKey(updated_nodes, obj.AxID())) {
-      if (!serializer_.SerializeChanges(obj, &update)) {
-        VLOG(1) << "Failed to serialize one accessibility event.";
-        continue;
-      }
+    if (!serializer_.SerializeChanges(obj, &event_msg.update)) {
+      VLOG(1) << "Failed to serialize one accessibility event.";
+      continue;
     }
 
-    // Keep track of the node ids in |update| so we can avoid serializing
-    // the same node twice, even if there are multiple events on that node.
-    for (size_t i = update_size; i < update.nodes.size(); ++i)
-      updated_nodes.insert(update.nodes[i].id);
-    update_size = update.nodes.size();
+    if (plugin_tree_source_)
+      AddPluginTreeToUpdate(&event_msg.update);
 
     event_msgs.push_back(event_msg);
 
+    // For each node in the update, set the location in our map from
+    // ids to locations.
+    for (size_t i = 0; i < event_msg.update.nodes.size(); ++i) {
+      ui::AXNodeData& src = event_msg.update.nodes[i];
+      ui::AXRelativeBounds& dst = locations_[event_msg.update.nodes[i].id];
+      dst.offset_container_id = src.offset_container_id;
+      dst.bounds = src.location;
+      dst.transform.reset(nullptr);
+      if (src.transform)
+        dst.transform.reset(new gfx::Transform(*src.transform));
+    }
+
     VLOG(1) << "Accessibility event: " << ui::ToString(event.event_type)
-            << " on node id " << event_msg.id;
+            << " on node id " << event_msg.id
+            << "\n" << event_msg.update.ToString();
   }
 
-  if (plugin_tree_source_)
-    AddPluginTreeToUpdate(&update);
-
-  VLOG(1) << "Accessibility update:\n" << update.ToString();
-
-  // For each node in the update, set the location in our map from
-  // ids to locations.
-  for (size_t i = 0; i < update.nodes.size(); ++i) {
-    ui::AXNodeData& src = update.nodes[i];
-    ui::AXRelativeBounds& dst = locations_[update.nodes[i].id];
-    dst.offset_container_id = src.offset_container_id;
-    dst.bounds = src.location;
-    dst.transform.reset(nullptr);
-    if (src.transform)
-      dst.transform.reset(new gfx::Transform(*src.transform));
-  }
-
-  Send(new AccessibilityHostMsg_Events(routing_id(), update, event_msgs,
-                                       reset_token_, ack_token_));
+  Send(new AccessibilityHostMsg_Events(routing_id(), event_msgs, reset_token_,
+                                       ack_token_));
   reset_token_ = 0;
 
   if (had_layout_complete_messages)

content/renderer/accessibility/render_accessibility_impl_browsertest.cc

diff --git a/content/renderer/accessibility/render_accessibility_impl_browsertest.cc b/content/renderer/accessibility/render_accessibility_impl_browsertest.cc
index cd4fc1b..a9bdd34 100644
--- a/content/renderer/accessibility/render_accessibility_impl_browsertest.cc
+++ b/content/renderer/accessibility/render_accessibility_impl_browsertest.cc
@@ -68,21 +68,28 @@
 
   void SetMode(ui::AXMode mode) { frame()->OnSetAccessibilityMode(mode); }
 
-  void GetLastTreeUpdate(content::AXContentTreeUpdate* update) {
+  void GetAllAccEvents(
+      std::vector<AccessibilityHostMsg_EventParams>* param_list) {
     const IPC::Message* message =
         sink_->GetUniqueMessageMatching(AccessibilityHostMsg_Events::ID);
     ASSERT_TRUE(message);
-    std::tuple<content::AXContentTreeUpdate,
-               std::vector<AccessibilityHostMsg_EventParams>, int, int>
-        param;
+    std::tuple<std::vector<AccessibilityHostMsg_EventParams>, int, int> param;
     AccessibilityHostMsg_Events::Read(message, &param);
-    *update = std::get<0>(param);
+    *param_list = std::get<0>(param);
+  }
+
+  void GetLastAccEvent(
+      AccessibilityHostMsg_EventParams* params) {
+    std::vector<AccessibilityHostMsg_EventParams> param_list;
+    GetAllAccEvents(&param_list);
+    ASSERT_GE(param_list.size(), 1U);
+    *params = param_list[0];
   }
 
   int CountAccessibilityNodesSentToBrowser() {
-    content::AXContentTreeUpdate update;
-    GetLastTreeUpdate(&update);
-    return update.nodes.size();
+    AccessibilityHostMsg_EventParams event;
+    GetLastAccEvent(&event);
+    return event.update.nodes.size();
   }
 
  protected:
@@ -126,9 +133,9 @@
   EXPECT_EQ(1, CountAccessibilityNodesSentToBrowser());
   {
     // Make sure it's the root object that was updated.
-    content::AXContentTreeUpdate update;
-    GetLastTreeUpdate(&update);
-    EXPECT_EQ(root_obj.AxID(), update.nodes[0].id);
+    AccessibilityHostMsg_EventParams event;
+    GetLastAccEvent(&event);
+    EXPECT_EQ(root_obj.AxID(), event.update.nodes[0].id);
   }
 
   // If we reload the page and send a event, we should send
@@ -198,15 +205,15 @@
       ui::AX_EVENT_CHILDREN_CHANGED);
 
   accessibility->SendPendingAccessibilityEvents();
-  content::AXContentTreeUpdate update;
-  GetLastTreeUpdate(&update);
-  ASSERT_EQ(2U, update.nodes.size());
+  AccessibilityHostMsg_EventParams event;
+  GetLastAccEvent(&event);
+  ASSERT_EQ(2U, event.update.nodes.size());
 
   // RenderAccessibilityImpl notices that 'C' is being reparented,
   // so it clears the subtree rooted at 'A', then updates 'A' and then 'C'.
-  EXPECT_EQ(node_a.AxID(), update.node_id_to_clear);
-  EXPECT_EQ(node_a.AxID(), update.nodes[0].id);
-  EXPECT_EQ(node_c.AxID(), update.nodes[1].id);
+  EXPECT_EQ(node_a.AxID(), event.update.node_id_to_clear);
+  EXPECT_EQ(node_a.AxID(), event.update.nodes[0].id);
+  EXPECT_EQ(node_c.AxID(), event.update.nodes[1].id);
   EXPECT_EQ(2, CountAccessibilityNodesSentToBrowser());
 }
 
@@ -248,14 +255,14 @@
       ui::AX_EVENT_CHILDREN_CHANGED);
 
   accessibility->SendPendingAccessibilityEvents();
-  content::AXContentTreeUpdate update;
-  GetLastTreeUpdate(&update);
+  AccessibilityHostMsg_EventParams event;
+  GetLastAccEvent(&event);
 
-  ASSERT_EQ(3U, update.nodes.size());
-  EXPECT_EQ(node_a.AxID(), update.node_id_to_clear);
-  EXPECT_EQ(node_a.AxID(), update.nodes[0].id);
-  EXPECT_EQ(node_b.AxID(), update.nodes[1].id);
-  EXPECT_EQ(node_c.AxID(), update.nodes[2].id);
+  ASSERT_EQ(3U, event.update.nodes.size());
+  EXPECT_EQ(node_a.AxID(), event.update.node_id_to_clear);
+  EXPECT_EQ(node_a.AxID(), event.update.nodes[0].id);
+  EXPECT_EQ(node_b.AxID(), event.update.nodes[1].id);
+  EXPECT_EQ(node_c.AxID(), event.update.nodes[2].id);
   EXPECT_EQ(3, CountAccessibilityNodesSentToBrowser());
 }
 

content/test/data/accessibility/event/listbox-next-expected-win.txt

diff --git a/content/test/data/accessibility/event/listbox-next-expected-win.txt b/content/test/data/accessibility/event/listbox-next-expected-win.txt
index 610e127..fa84e5a3 100644
--- a/content/test/data/accessibility/event/listbox-next-expected-win.txt
+++ b/content/test/data/accessibility/event/listbox-next-expected-win.txt
@@ -1,5 +1,5 @@
-EVENT_OBJECT_STATECHANGE on role=ROLE_SYSTEM_LISTITEM name="Orange" SELECTED,FOCUSED,FOCUSABLE,SELECTABLE
-EVENT_OBJECT_SELECTION on role=ROLE_SYSTEM_LISTITEM name="Orange" SELECTED,FOCUSED,FOCUSABLE,SELECTABLE
+EVENT_OBJECT_STATECHANGE on role=ROLE_SYSTEM_LISTITEM name="Orange" SELECTED,FOCUSABLE,SELECTABLE
+EVENT_OBJECT_SELECTION on role=ROLE_SYSTEM_LISTITEM name="Orange" SELECTED,FOCUSABLE,SELECTABLE
 EVENT_OBJECT_STATECHANGE on role=ROLE_SYSTEM_LISTITEM name="Apple" FOCUSABLE,SELECTABLE
 IA2_EVENT_ACTIVE_DESCENDANT_CHANGED on role=ROLE_SYSTEM_LIST FOCUSABLE IA2_STATE_VERTICAL
 EVENT_OBJECT_SELECTIONWITHIN on role=ROLE_SYSTEM_LIST FOCUSABLE IA2_STATE_VERTICAL

content/test/data/content-sniffer-test0.html.mock-http-headers

diff --git a/content/test/data/content-sniffer-test0.html.mock-http-headers b/content/test/data/content-sniffer-test0.html.mock-http-headers
index 47a3b3c..a919d525 100644
--- a/content/test/data/content-sniffer-test0.html.mock-http-headers
+++ b/content/test/data/content-sniffer-test0.html.mock-http-headers
@@ -1,2 +1 @@
 HTTP/1.1 200 OK
-Content-Length: 121

content/test/data/content-sniffer-test1.html.mock-http-headers

diff --git a/content/test/data/content-sniffer-test1.html.mock-http-headers b/content/test/data/content-sniffer-test1.html.mock-http-headers
index 2aa3579..05079a91 100644
--- a/content/test/data/content-sniffer-test1.html.mock-http-headers
+++ b/content/test/data/content-sniffer-test1.html.mock-http-headers
@@ -1,3 +1,2 @@
 HTTP/1.1 200 OK
 Content-Type: text/plain; charset=utf-8
-Content-Length: 125

content/test/data/content-sniffer-test2.html.mock-http-headers

diff --git a/content/test/data/content-sniffer-test2.html.mock-http-headers b/content/test/data/content-sniffer-test2.html.mock-http-headers
index 5c28dff..7b2176c 100644
--- a/content/test/data/content-sniffer-test2.html.mock-http-headers
+++ b/content/test/data/content-sniffer-test2.html.mock-http-headers
@@ -1,3 +1,2 @@
 HTTP/1.1 200 OK
 Content-Type: image/gif
-Content-Length: 142

content/test/data/content-sniffer-test3.html.mock-http-headers

diff --git a/content/test/data/content-sniffer-test3.html.mock-http-headers b/content/test/data/content-sniffer-test3.html.mock-http-headers
index 9dd16d42..524e3d8c 100644
--- a/content/test/data/content-sniffer-test3.html.mock-http-headers
+++ b/content/test/data/content-sniffer-test3.html.mock-http-headers
@@ -1,3 +1,2 @@
 HTTP/1.1 200 OK
-Content-Length: 472
 Content-Type: text/html

content/test/gpu/gpu_tests/pixel_expectations.py

diff --git a/content/test/gpu/gpu_tests/pixel_expectations.py b/content/test/gpu/gpu_tests/pixel_expectations.py
index 8b64811..274eb29 100644
--- a/content/test/gpu/gpu_tests/pixel_expectations.py
+++ b/content/test/gpu/gpu_tests/pixel_expectations.py
@@ -60,22 +60,6 @@
     self.Flaky('Pixel_OffscreenCanvasTransferAfterStyleResize',
               ['mac', 'linux', 'win', 'android'], bug=735171)
 
-    # TODO(fserb): already fixed, just needed to submit so the tests pass.
-    self.Fail('Pixel_OffscreenCanvasAccelerated2D',
-        ['mac', 'linux', 'win', 'android'])
-    self.Fail('Pixel_OffscreenCanvasAccelerated2DWorker',
-        ['mac', 'linux', 'win', 'android'])
-    self.Fail('Pixel_OffscreenCanvasUnaccelerated2D',
-        ['mac', 'linux', 'win', 'android'])
-    self.Fail('Pixel_OffscreenCanvasUnaccelerated2DGPUCompositing',
-        ['mac', 'linux', 'win', 'android'])
-    self.Fail('Pixel_OffscreenCanvasUnaccelerated2DGPUCompositingWorker',
-        ['mac', 'linux', 'win', 'android'])
-    self.Fail('Pixel_OffscreenCanvasUnaccelerated2DWorker',
-        ['mac', 'linux', 'win', 'android'])
-
-
-
     # TODO(junov): update reference images
     self.Fail('Pixel_CSSFilterEffects', ['mac'], bug=721727)
     self.Fail('Pixel_CSSFilterEffects_NoOverlays', ['mac'], bug=721727)

device/vr/android/gvr/gvr_device.cc

diff --git a/device/vr/android/gvr/gvr_device.cc b/device/vr/android/gvr/gvr_device.cc
index daa90a8..8b0630c7 100644
--- a/device/vr/android/gvr/gvr_device.cc
+++ b/device/vr/android/gvr/gvr_device.cc
@@ -48,13 +48,6 @@
                                          std::move(request), callback);
 }
 
-void GvrDevice::SetSecureOrigin(bool secure_origin) {
-  secure_origin_ = secure_origin;
-  GvrDelegate* delegate = GetGvrDelegate();
-  if (delegate)
-    delegate->SetWebVRSecureOrigin(secure_origin_);
-}
-
 void GvrDevice::ExitPresent() {
   GvrDelegateProvider* delegate_provider = gvr_provider_->GetDelegateProvider();
   if (delegate_provider)
@@ -95,11 +88,6 @@
 }
 
 void GvrDevice::OnDelegateChanged() {
-  GvrDelegate* delegate = GetGvrDelegate();
-  // Notify the clients that this device has changed
-  if (delegate)
-    delegate->SetWebVRSecureOrigin(secure_origin_);
-
   OnChanged();
 }
 

device/vr/android/gvr/gvr_device.h

diff --git a/device/vr/android/gvr/gvr_device.h b/device/vr/android/gvr/gvr_device.h
index de8aa74..a216a23 100644
--- a/device/vr/android/gvr/gvr_device.h
+++ b/device/vr/android/gvr/gvr_device.h
@@ -26,7 +26,6 @@
   void RequestPresent(mojom::VRSubmitFrameClientPtr submit_client,
                       mojom::VRPresentationProviderRequest request,
                       const base::Callback<void(bool)>& callback) override;
-  void SetSecureOrigin(bool secure_origin) override;
   void ExitPresent() override;
   void GetNextMagicWindowPose(
       VRDisplayImpl* display,
@@ -41,7 +40,6 @@
   GvrDelegate* GetGvrDelegate();
 
   GvrDeviceProvider* gvr_provider_;
-  bool secure_origin_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(GvrDevice);
 };

device/vr/openvr/openvr_device.cc

diff --git a/device/vr/openvr/openvr_device.cc b/device/vr/openvr/openvr_device.cc
index 185f068..397e68f6 100644
--- a/device/vr/openvr/openvr_device.cc
+++ b/device/vr/openvr/openvr_device.cc
@@ -197,10 +197,6 @@
   // We don't support presentation currently.
 }
 
-void OpenVRDevice::SetSecureOrigin(bool secure_origin) {
-  // We don't support presentation currently, so don't do anything.
-}
-
 void OpenVRDevice::ExitPresent() {
   // We don't support presentation currently, so don't do anything.
 }

device/vr/openvr/openvr_device.h

diff --git a/device/vr/openvr/openvr_device.h b/device/vr/openvr/openvr_device.h
index 1c5ed71..a5c8d56 100644
--- a/device/vr/openvr/openvr_device.h
+++ b/device/vr/openvr/openvr_device.h
@@ -33,7 +33,6 @@
   void RequestPresent(mojom::VRSubmitFrameClientPtr submit_client,
                       mojom::VRPresentationProviderRequest request,
                       const base::Callback<void(bool)>& callback) override;
-  void SetSecureOrigin(bool secure_origin) override;
   void ExitPresent() override;
   void GetNextMagicWindowPose(
       mojom::VRDisplay::GetNextMagicWindowPoseCallback callback) override;

device/vr/test/fake_vr_device.cc

diff --git a/device/vr/test/fake_vr_device.cc b/device/vr/test/fake_vr_device.cc
index dde29f9..4e4ad86 100644
--- a/device/vr/test/fake_vr_device.cc
+++ b/device/vr/test/fake_vr_device.cc
@@ -65,8 +65,6 @@
   callback.Run(true);
 }
 
-void FakeVRDevice::SetSecureOrigin(bool secure_origin) {}
-
 void FakeVRDevice::ExitPresent() {
   OnExitPresent();
 }

device/vr/test/fake_vr_device.h

diff --git a/device/vr/test/fake_vr_device.h b/device/vr/test/fake_vr_device.h
index d816b0c..6412fd1 100644
--- a/device/vr/test/fake_vr_device.h
+++ b/device/vr/test/fake_vr_device.h
@@ -29,7 +29,6 @@
   void RequestPresent(mojom::VRSubmitFrameClientPtr submit_client,
                       mojom::VRPresentationProviderRequest request,
                       const base::Callback<void(bool)>& callback) override;
-  void SetSecureOrigin(bool secure_origin) override;
   void ExitPresent() override;
   void GetNextMagicWindowPose(
       VRDisplayImpl* display,

device/vr/vr_device.h

diff --git a/device/vr/vr_device.h b/device/vr/vr_device.h
index 2c1f39d..995e698 100644
--- a/device/vr/vr_device.h
+++ b/device/vr/vr_device.h
@@ -34,7 +34,6 @@
   virtual void RequestPresent(mojom::VRSubmitFrameClientPtr submit_client,
                               mojom::VRPresentationProviderRequest request,
                               const base::Callback<void(bool)>& callback) = 0;
-  virtual void SetSecureOrigin(bool secure_origin) = 0;
   virtual void ExitPresent() = 0;
   virtual void GetNextMagicWindowPose(
       VRDisplayImpl* display,
@@ -48,6 +47,7 @@
 
   bool IsAccessAllowed(VRDisplayImpl* display);
   bool CheckPresentingDisplay(VRDisplayImpl* display);
+  VRDisplayImpl* GetPresentingDisplay() { return presenting_display_; }
 
   void OnChanged();
   void OnExitPresent();

device/vr/vr_display_impl.cc

diff --git a/device/vr/vr_display_impl.cc b/device/vr/vr_display_impl.cc
index 2dc5f5f2..fe90329 100644
--- a/device/vr/vr_display_impl.cc
+++ b/device/vr/vr_display_impl.cc
@@ -59,8 +59,7 @@
   client_->OnDeactivate(reason);
 }
 
-void VRDisplayImpl::RequestPresent(bool secure_origin,
-                                   mojom::VRSubmitFrameClientPtr submit_client,
+void VRDisplayImpl::RequestPresent(mojom::VRSubmitFrameClientPtr submit_client,
                                    mojom::VRPresentationProviderRequest request,
                                    RequestPresentCallback callback) {
   if (!device_->IsAccessAllowed(this)) {
@@ -68,19 +67,16 @@
     return;
   }
 
-  device_->RequestPresent(std::move(submit_client), std::move(request),
-                          base::Bind(&VRDisplayImpl::RequestPresentResult,
-                                     weak_ptr_factory_.GetWeakPtr(),
-                                     base::Passed(&callback), secure_origin));
+  device_->RequestPresent(
+      std::move(submit_client), std::move(request),
+      base::Bind(&VRDisplayImpl::RequestPresentResult,
+                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&callback)));
 }
 
 void VRDisplayImpl::RequestPresentResult(RequestPresentCallback callback,
-                                         bool secure_origin,
                                          bool success) {
-  if (success) {
+  if (success)
     device_->SetPresentingDisplay(this);
-    device_->SetSecureOrigin(secure_origin);
-  }
   std::move(callback).Run(success);
 }
 

device/vr/vr_display_impl.h

diff --git a/device/vr/vr_display_impl.h b/device/vr/vr_display_impl.h
index b09ce5f..b1ff4de 100644
--- a/device/vr/vr_display_impl.h
+++ b/device/vr/vr_display_impl.h
@@ -48,15 +48,13 @@
  private:
   friend class VRDisplayImplTest;
 
-  void RequestPresent(bool secure_origin,
-                      mojom::VRSubmitFrameClientPtr submit_client,
+  void RequestPresent(mojom::VRSubmitFrameClientPtr submit_client,
                       mojom::VRPresentationProviderRequest request,
                       RequestPresentCallback callback) override;
   void ExitPresent() override;
   void GetNextMagicWindowPose(GetNextMagicWindowPoseCallback callback) override;
 
   void RequestPresentResult(RequestPresentCallback callback,
-                            bool secure_origin,
                             bool success);
 
   mojo::Binding<mojom::VRDisplay> binding_;

device/vr/vr_display_impl_unittest.cc

diff --git a/device/vr/vr_display_impl_unittest.cc b/device/vr/vr_display_impl_unittest.cc
index a1628db..731056f 100644
--- a/device/vr/vr_display_impl_unittest.cc
+++ b/device/vr/vr_display_impl_unittest.cc
@@ -53,7 +53,7 @@
     device::mojom::VRSubmitFrameClientPtr submit_client = nullptr;
     device::mojom::VRPresentationProviderRequest request = nullptr;
     display_impl->RequestPresent(
-        true, std::move(submit_client), std::move(request),
+        std::move(submit_client), std::move(request),
         base::Bind(&VRDisplayImplTest::onPresentComplete,
                    base::Unretained(this)));
   }

device/vr/vr_service.mojom

diff --git a/device/vr/vr_service.mojom b/device/vr/vr_service.mojom
index 075bfde..4c8e693 100644
--- a/device/vr/vr_service.mojom
+++ b/device/vr/vr_service.mojom
@@ -84,16 +84,17 @@
   OnSubmitFrameRendered();
 };
 
-// Represents a physical VR device that can be used to present WebVR content, or get orientation
-// data (VRPose) when not presenting (aka magic window).
+// Represents a physical VR device that can be used to present WebVR content,
+// or get orientation data (VRPose) when not presenting (aka magic window).
 interface VRDisplay {
-  RequestPresent(bool secure_origin, VRSubmitFrameClient client,
+  RequestPresent(VRSubmitFrameClient client,
                  VRPresentationProvider& request) => (bool success);
   ExitPresent();
   GetNextMagicWindowPose() => (VRPose? pose);
 };
 
-// Provides the necessary functionality for a presenting WebVR page to draw frames for a VrDisplay.
+// Provides the necessary functionality for a presenting WebVR page to draw
+// frames for a VrDisplay.
 interface VRPresentationProvider {
   enum VSyncStatus { SUCCESS, CLOSING };
 

gpu/ipc/service/switches.cc

diff --git a/gpu/ipc/service/switches.cc b/gpu/ipc/service/switches.cc
index 4a312ea..1282e02 100644
--- a/gpu/ipc/service/switches.cc
+++ b/gpu/ipc/service/switches.cc
@@ -14,6 +14,6 @@
 const char kGpuSandboxStartEarly[] = "gpu-sandbox-start-early";
 
 const base::Feature kDirectCompositionOverlays{
-    "DirectCompositionOverlays", base::FEATURE_DISABLED_BY_DEFAULT};
+    "DirectCompositionOverlays", base::FEATURE_ENABLED_BY_DEFAULT};
 
 }  // namespace switches

ios/chrome/app/strings/ios_strings.grd

diff --git a/ios/chrome/app/strings/ios_strings.grd b/ios/chrome/app/strings/ios_strings.grd
index cbdc64d0..a231e40 100644
--- a/ios/chrome/app/strings/ios_strings.grd
+++ b/ios/chrome/app/strings/ios_strings.grd
@@ -746,6 +746,9 @@
       <message name="IDS_IOS_NEW_TAB_INCOGNITO" desc="Title for the Incognito panel of the new tab page.">
         Incognito
       </message>
+      <message name="IDS_IOS_NEW_TAB_IPH_PROMOTION_TEXT" desc="Text for the New Tab Tip in-product help promotion, explaining that new tabs can be opened. [iOS only]" meaning="The user has never created a new tab, and a bubble is displayed pointing to the tab switcher to inform users how to create tabs.">
+        Create multiple tabs for all your tasks
+      </message>
       <message name="IDS_IOS_NEW_TAB_LEARN_MORE_ABOUT_SUGGESTED_CONTENT" desc="Text in the footer of the New Tab Page. Part of the text is a link to a help center page where the user can learn more about suggested content.">
         <ph name="BEGIN_LINK">BEGIN_LINK</ph>Learn more<ph name="END_LINK">END_LINK</ph> about suggested content
       </message>

ios/chrome/browser/about_flags.mm

diff --git a/ios/chrome/browser/about_flags.mm b/ios/chrome/browser/about_flags.mm
index a102246..7fcf8c64 100644
--- a/ios/chrome/browser/about_flags.mm
+++ b/ios/chrome/browser/about_flags.mm
@@ -137,6 +137,9 @@
     {"web-payments", flag_descriptions::kWebPaymentsName,
      flag_descriptions::kWebPaymentsDescription, flags_ui::kOsIos,
      FEATURE_VALUE_TYPE(payments::features::kWebPayments)},
+    {"web-payments-native-apps", flag_descriptions::kWebPaymentsNativeAppsName,
+     flag_descriptions::kWebPaymentsNativeAppsDescription, flags_ui::kOsIos,
+     FEATURE_VALUE_TYPE(payments::features::kWebPaymentsNativeApps)},
     {"ios-captive-portal", flag_descriptions::kCaptivePortalName,
      flag_descriptions::kCaptivePortalDescription, flags_ui::kOsIos,
      FEATURE_VALUE_TYPE(kCaptivePortalFeature)},

ios/chrome/browser/ios_chrome_flag_descriptions.cc

diff --git a/ios/chrome/browser/ios_chrome_flag_descriptions.cc b/ios/chrome/browser/ios_chrome_flag_descriptions.cc
index 57197a2..389f88d 100644
--- a/ios/chrome/browser/ios_chrome_flag_descriptions.cc
+++ b/ios/chrome/browser/ios_chrome_flag_descriptions.cc
@@ -47,6 +47,11 @@
 const char kWebPaymentsDescription[] =
     "Enable Payment Request API integration, a JavaScript API for merchants.";
 
+const char kWebPaymentsNativeAppsName[] = "Web Payments Native Apps";
+const char kWebPaymentsNativeAppsDescription[] =
+    "Enable third party iOS native apps as payments methods within Payment "
+    "Request.";
+
 const char kCaptivePortalName[] = "Captive Portal";
 const char kCaptivePortalDescription[] =
     "When enabled, the Captive Portal landing page will be displayed if it is "

ios/chrome/browser/ios_chrome_flag_descriptions.h

diff --git a/ios/chrome/browser/ios_chrome_flag_descriptions.h b/ios/chrome/browser/ios_chrome_flag_descriptions.h
index 0598bff..a3289f56 100644
--- a/ios/chrome/browser/ios_chrome_flag_descriptions.h
+++ b/ios/chrome/browser/ios_chrome_flag_descriptions.h
@@ -43,6 +43,11 @@
 extern const char kWebPaymentsName[];
 extern const char kWebPaymentsDescription[];
 
+// Title and description for the flag to enable third party payment app
+// integration with Web Payments.
+extern const char kWebPaymentsNativeAppsName[];
+extern const char kWebPaymentsNativeAppsDescription[];
+
 // Title and description for the flag to enable Captive Portal Login.
 extern const char kCaptivePortalName[];
 extern const char kCaptivePortalDescription[];

ios/chrome/browser/metrics/tab_usage_recorder_egtest.mm

diff --git a/ios/chrome/browser/metrics/tab_usage_recorder_egtest.mm b/ios/chrome/browser/metrics/tab_usage_recorder_egtest.mm
index a4553c4e..989be9a 100644
--- a/ios/chrome/browser/metrics/tab_usage_recorder_egtest.mm
+++ b/ios/chrome/browser/metrics/tab_usage_recorder_egtest.mm
@@ -12,9 +12,6 @@
 #include "components/strings/grit/components_strings.h"
 #import "ios/chrome/browser/metrics/tab_usage_recorder.h"
 #import "ios/chrome/browser/metrics/tab_usage_recorder_test_util.h"
-#import "ios/chrome/browser/ui/settings/privacy_collection_view_controller.h"
-#import "ios/chrome/browser/ui/settings/settings_collection_view_controller.h"
-#import "ios/chrome/browser/ui/toolbar/toolbar_controller.h"
 #include "ios/chrome/browser/ui/tools_menu/tools_menu_constants.h"
 #include "ios/chrome/browser/ui/ui_util.h"
 #import "ios/chrome/browser/ui/uikit_ui_util.h"
@@ -112,9 +109,7 @@
 // synchronization.
 void OpenNewMainTabUsingUIUnsynced() {
   int nb_main_tab = chrome_test_util::GetMainTabCount();
-  id<GREYMatcher> tool_menu_matcher =
-      grey_accessibilityID(kToolbarToolsMenuButtonIdentifier);
-  WaitAndTap(tool_menu_matcher, @"Tool menu");
+  WaitAndTap(chrome_test_util::ToolsMenuButton(), @"Tool menu");
   id<GREYMatcher> new_main_tab_button_matcher =
       grey_accessibilityID(kToolsMenuNewTabId);
   WaitAndTap(new_main_tab_button_matcher, @"New tab button");
@@ -527,9 +522,7 @@
   [[GREYConfiguration sharedInstance]
           setValue:@(NO)
       forConfigKey:kGREYConfigKeySynchronizationEnabled];
-  id<GREYMatcher> toolMenuMatcher =
-      grey_accessibilityID(kToolbarToolsMenuButtonIdentifier);
-  Wait(toolMenuMatcher, @"Tool Menu");
+  Wait(chrome_test_util::ToolsMenuButton(), @"Tool Menu");
 
   GREYAssertTrue(chrome_test_util::SimulateTabsBackgrounding(),
                  @"Failed to simulate tab backgrounding.");

ios/chrome/browser/passwords/password_controller_unittest.mm

diff --git a/ios/chrome/browser/passwords/password_controller_unittest.mm b/ios/chrome/browser/passwords/password_controller_unittest.mm
index 9f99187..71e3663 100644
--- a/ios/chrome/browser/passwords/password_controller_unittest.mm
+++ b/ios/chrome/browser/passwords/password_controller_unittest.mm
@@ -47,6 +47,7 @@
 
 using autofill::PasswordForm;
 using autofill::PasswordFormFillData;
+using testing::NiceMock;
 using testing::Return;
 
 namespace {
@@ -95,7 +96,7 @@
     web::WebState* web_state,
     password_manager::PasswordStore* store,
     MockPasswordManagerClient** weak_client) {
-  auto client = base::MakeUnique<MockPasswordManagerClient>(store);
+  auto client = base::MakeUnique<NiceMock<MockPasswordManagerClient>>(store);
   if (weak_client)
     *weak_client = client.get();
   return [[PasswordController alloc] initWithWebState:web_state

ios/chrome/browser/payments/ios_payment_instrument.mm

diff --git a/ios/chrome/browser/payments/ios_payment_instrument.mm b/ios/chrome/browser/payments/ios_payment_instrument.mm
index 7e48564..29522f6 100644
--- a/ios/chrome/browser/payments/ios_payment_instrument.mm
+++ b/ios/chrome/browser/payments/ios_payment_instrument.mm
@@ -49,8 +49,9 @@
 void IOSPaymentInstrument::InvokePaymentApp(
     PaymentInstrument::Delegate* delegate) {
   DCHECK(delegate);
-  [payment_request_ui_delegate_ launchAppWithUniversalLink:universal_link_
-                                        instrumentDelegate:delegate];
+  [payment_request_ui_delegate_ paymentInstrument:this
+                       launchAppWithUniversalLink:universal_link_
+                               instrumentDelegate:delegate];
 }
 
 bool IOSPaymentInstrument::IsCompleteForPayment() const {

ios/chrome/browser/payments/payment_request.h

diff --git a/ios/chrome/browser/payments/payment_request.h b/ios/chrome/browser/payments/payment_request.h
index 013dc5b..75215f9 100644
--- a/ios/chrome/browser/payments/payment_request.h
+++ b/ios/chrome/browser/payments/payment_request.h
@@ -21,6 +21,7 @@
 #include "components/payments/core/payment_options_provider.h"
 #include "components/payments/core/payment_request_base_delegate.h"
 #include "components/payments/core/payments_profile_comparator.h"
+#import "ios/chrome/browser/payments/ios_payment_instrument_finder.h"
 #import "ios/chrome/browser/payments/payment_response_helper.h"
 #include "ios/web/public/payments/payment_request.h"
 #include "url/gurl.h"
@@ -45,20 +46,25 @@
 class WebState;
 }  // namespace web
 
-// A protocol implementd by any UI classes that the PaymentRequest object
-// needs to communicate with in order to perform certain actions such as
-// initiating UI to request full card details for payment.
 @protocol PaymentRequestUIDelegate<NSObject>
 
+// Called when all payment instruments have been fetched.
+- (void)paymentRequestDidFetchPaymentMethods:
+    (payments::PaymentRequest*)paymentRequest;
+
+// Called when the credit card unmask UI should be revealed so that the user
+// may provide provide card details such as their CVC.
 - (void)
+       paymentRequest:(payments::PaymentRequest*)paymentRequest
 requestFullCreditCard:(const autofill::CreditCard&)creditCard
        resultDelegate:
            (base::WeakPtr<autofill::payments::FullCardRequest::ResultDelegate>)
-               resultDelegate;
+               delegate;
 
-- (void)launchAppWithUniversalLink:(std::string)universalLink
-                instrumentDelegate:
-                    (payments::PaymentInstrument::Delegate*)instrumentDelegate;
+// Called when a native iOS payment app should be launched.
+- (void)paymentInstrument:(payments::IOSPaymentInstrument*)paymentInstrument
+    launchAppWithUniversalLink:(std::string)universalLink
+            instrumentDelegate:(payments::PaymentInstrument::Delegate*)delegate;
 
 @end
 
@@ -244,6 +250,9 @@
   // method above returns.
   const PaymentsProfileComparator* profile_comparator() const;
 
+  // Returns whether or not all payment instruments have been fetched.
+  bool payment_instruments_ready() { return payment_instruments_ready_; }
+
   // Returns whether the current PaymentRequest can be used to make a payment.
   bool CanMakePayment() const;
 
@@ -265,10 +274,21 @@
   // cached profiles ordered by completeness.
   void PopulateAvailableProfiles();
 
-  // Fetches the payment methods for this user that match a supported type
-  // specified in |web_payment_request_| and stores copies of them, owned
-  // by this PaymentRequest, in payment_method_cache_.
-  void PopulatePaymentMethodCache();
+  // Parses the accepted payment method types and card networks requested by
+  // the merchant.
+  void ParsePaymentMethodData();
+
+  // Starts creating the native app payment methods asynchronously.
+  void CreateNativeAppPaymentMethods();
+
+  // Stores a copy of |native_app_instruments| and autofill payment instruments
+  // that match the supported types specified in |web_payment_request_|. Sets
+  // |selected_payment_method_| and notifies the UI delegate that the payment
+  // methods are ready. This serves as a callback for when all native app
+  // payment instruments are ready.
+  void PopulatePaymentMethodCache(
+      std::vector<std::unique_ptr<IOSPaymentInstrument>>
+          native_app_instruments);
 
   // Sets the available payment methods as references to the cached payment
   // methods.
@@ -360,6 +380,13 @@
 
   std::unique_ptr<PaymentResponseHelper> response_helper_;
 
+  // Boolean to track if payment instruments are still being fetched.
+  bool payment_instruments_ready_;
+
+  // Finds all iOS payment instruments for the url payment methods requested by
+  // the merchant.
+  IOSPaymentInstrumentFinder ios_instrument_finder_;
+
   DISALLOW_COPY_AND_ASSIGN(PaymentRequest);
 };
 

ios/chrome/browser/payments/payment_request.mm

diff --git a/ios/chrome/browser/payments/payment_request.mm b/ios/chrome/browser/payments/payment_request.mm
index ca3c8bd4..2882a1f 100644
--- a/ios/chrome/browser/payments/payment_request.mm
+++ b/ios/chrome/browser/payments/payment_request.mm
@@ -7,6 +7,7 @@
 #include <algorithm>
 
 #include "base/containers/adapters.h"
+#include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ -18,12 +19,14 @@
 #include "components/autofill/core/browser/validation.h"
 #include "components/payments/core/autofill_payment_instrument.h"
 #include "components/payments/core/currency_formatter.h"
+#include "components/payments/core/features.h"
 #include "components/payments/core/payment_request_data_util.h"
 #include "components/prefs/pref_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "ios/chrome/browser/application_context.h"
 #include "ios/chrome/browser/autofill/validation_rules_storage_factory.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
+#import "ios/chrome/browser/payments/ios_payment_instrument.h"
 #import "ios/chrome/browser/payments/payment_request_util.h"
 #include "ios/chrome/browser/signin/signin_manager_factory.h"
 #include "ios/web/public/payments/payment_request.h"
@@ -77,12 +80,17 @@
       selected_payment_method_(nullptr),
       selected_shipping_option_(nullptr),
       profile_comparator_(GetApplicationLocale(), *this),
-      journey_logger_(IsIncognito(), GetLastCommittedURL(), GetUkmRecorder()) {
+      journey_logger_(IsIncognito(), GetLastCommittedURL(), GetUkmRecorder()),
+      payment_instruments_ready_(false),
+      ios_instrument_finder_(
+          personal_data_manager_->GetURLRequestContextGetter(),
+          payment_request_ui_delegate_) {
   PopulateAvailableShippingOptions();
   PopulateProfileCache();
   PopulateAvailableProfiles();
-  PopulatePaymentMethodCache();
-  PopulateAvailablePaymentMethods();
+
+  ParsePaymentMethodData();
+  CreateNativeAppPaymentMethods();
 
   SetSelectedShippingOption();
 
@@ -104,15 +112,6 @@
     }
   }
 
-  const auto first_complete_payment_method =
-      std::find_if(payment_methods_.begin(), payment_methods_.end(),
-                   [this](PaymentInstrument* payment_method) {
-                     return payment_method->IsCompleteForPayment() &&
-                            payment_method->IsExactlyMatchingMerchantRequest();
-                   });
-  if (first_complete_payment_method != payment_methods_.end())
-    selected_payment_method_ = *first_complete_payment_method;
-
   // Kickoff the process of loading the rules (which is asynchronous) for each
   // profile's country, to get faster address normalization later.
   for (const autofill::AutofillProfile* profile :
@@ -159,8 +158,9 @@
     const autofill::CreditCard& credit_card,
     base::WeakPtr<autofill::payments::FullCardRequest::ResultDelegate>
         result_delegate) {
-  [payment_request_ui_delegate_ requestFullCreditCard:credit_card
-                                       resultDelegate:result_delegate];
+  [payment_request_ui_delegate_ paymentRequest:this
+                         requestFullCreditCard:credit_card
+                                resultDelegate:result_delegate];
 }
 
 AddressNormalizer* PaymentRequest::GetAddressNormalizer() {
@@ -370,7 +370,7 @@
   selected_payment_method_->RecordUse();
 }
 
-void PaymentRequest::PopulatePaymentMethodCache() {
+void PaymentRequest::ParsePaymentMethodData() {
   for (const PaymentMethodData& method_data_entry :
        web_payment_request_.method_data) {
     for (const std::string& method : method_data_entry.supported_methods) {
@@ -387,21 +387,60 @@
 
   data_util::ParseSupportedCardTypes(web_payment_request_.method_data,
                                      &supported_card_types_set_);
+}
 
+void PaymentRequest::CreateNativeAppPaymentMethods() {
+  if (!base::FeatureList::IsEnabled(
+          payments::features::kWebPaymentsNativeApps)) {
+    url_payment_method_identifiers_ = std::vector<GURL>();
+    PopulatePaymentMethodCache(
+        std::vector<std::unique_ptr<IOSPaymentInstrument>>());
+    return;
+  }
+
+  url_payment_method_identifiers_ =
+      ios_instrument_finder_.CreateIOSPaymentInstrumentsForMethods(
+          url_payment_method_identifiers_,
+          base::BindOnce(&PaymentRequest::PopulatePaymentMethodCache,
+                         base::Unretained(this)));
+}
+
+void PaymentRequest::PopulatePaymentMethodCache(
+    std::vector<std::unique_ptr<IOSPaymentInstrument>> native_app_instruments) {
   const std::vector<autofill::CreditCard*>& credit_cards_to_suggest =
       personal_data_manager_->GetCreditCardsToSuggest();
-  // Return early if the user has no stored credit cards.
-  if (credit_cards_to_suggest.empty())
-    return;
 
-  // TODO(crbug.com/602666): Determine the number of possible payment methods so
-  // that we can reserve enough space in the following vector.
+  // Return early if the user has no stored credit cards or installed payment
+  // apps.
+  if (native_app_instruments.empty() && credit_cards_to_suggest.empty()) {
+    payment_instruments_ready_ = true;
+    [payment_request_ui_delegate_ paymentRequestDidFetchPaymentMethods:this];
+    return;
+  }
 
   payment_method_cache_.clear();
-  payment_method_cache_.reserve(credit_cards_to_suggest.size());
+  payment_method_cache_.reserve(native_app_instruments.size() +
+                                credit_cards_to_suggest.size());
+
+  for (auto& instrument : native_app_instruments)
+    payment_method_cache_.push_back(std::move(instrument));
 
   for (const auto* credit_card : credit_cards_to_suggest)
     AddAutofillPaymentInstrument(*credit_card);
+
+  PopulateAvailablePaymentMethods();
+
+  const auto first_complete_payment_method =
+      std::find_if(payment_methods_.begin(), payment_methods_.end(),
+                   [this](PaymentInstrument* payment_method) {
+                     return payment_method->IsCompleteForPayment() &&
+                            payment_method->IsExactlyMatchingMerchantRequest();
+                   });
+  if (first_complete_payment_method != payment_methods_.end())
+    selected_payment_method_ = *first_complete_payment_method;
+
+  payment_instruments_ready_ = true;
+  [payment_request_ui_delegate_ paymentRequestDidFetchPaymentMethods:this];
 }
 
 void PaymentRequest::PopulateAvailablePaymentMethods() {

ios/chrome/browser/payments/payment_request_unittest.mm

diff --git a/ios/chrome/browser/payments/payment_request_unittest.mm b/ios/chrome/browser/payments/payment_request_unittest.mm
index d30191eb..38206f4 100644
--- a/ios/chrome/browser/payments/payment_request_unittest.mm
+++ b/ios/chrome/browser/payments/payment_request_unittest.mm
@@ -7,6 +7,7 @@
 #include <memory>
 
 #include "base/strings/utf_string_conversions.h"
+#include "base/test/scoped_feature_list.h"
 #include "base/test/scoped_task_environment.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/autofill_type.h"
@@ -14,6 +15,7 @@
 #include "components/autofill/core/browser/test_personal_data_manager.h"
 #include "components/payments/core/autofill_payment_instrument.h"
 #include "components/payments/core/currency_formatter.h"
+#include "components/payments/core/features.h"
 #include "components/payments/core/payment_method_data.h"
 #include "ios/chrome/browser/application_context.h"
 #include "ios/chrome/browser/browser_state/test_chrome_browser_state.h"
@@ -145,6 +147,9 @@
   web::PaymentRequest web_payment_request;
   autofill::TestPersonalDataManager personal_data_manager;
 
+  base::test::ScopedFeatureList feature_list;
+  feature_list.InitAndEnableFeature(payments::features::kWebPaymentsNativeApps);
+
   PaymentMethodData method_datum1;
   method_datum1.supported_methods.push_back("visa");
   method_datum1.supported_methods.push_back("mastercard");
@@ -158,6 +163,7 @@
   TestPaymentRequest payment_request(web_payment_request,
                                      chrome_browser_state_.get(), &web_state_,
                                      &personal_data_manager);
+  payment_request.ResetParsedPaymentMethodData();
   ASSERT_EQ(2U, payment_request.supported_card_networks().size());
   EXPECT_EQ("visa", payment_request.supported_card_networks()[0]);
   EXPECT_EQ("mastercard", payment_request.supported_card_networks()[1]);
@@ -172,6 +178,9 @@
   web::PaymentRequest web_payment_request;
   autofill::TestPersonalDataManager personal_data_manager;
 
+  base::test::ScopedFeatureList feature_list;
+  feature_list.InitAndEnableFeature(payments::features::kWebPaymentsNativeApps);
+
   PaymentMethodData method_datum1;
   method_datum1.supported_methods.push_back("visa");
   method_datum1.supported_methods.push_back("https://bobpay.com");
@@ -191,6 +200,7 @@
   TestPaymentRequest payment_request(web_payment_request,
                                      chrome_browser_state_.get(), &web_state_,
                                      &personal_data_manager);
+  payment_request.ResetParsedPaymentMethodData();
   ASSERT_EQ(2U, payment_request.supported_card_networks().size());
   EXPECT_EQ("visa", payment_request.supported_card_networks()[0]);
   EXPECT_EQ("mastercard", payment_request.supported_card_networks()[1]);

ios/chrome/browser/payments/test_payment_request.h

diff --git a/ios/chrome/browser/payments/test_payment_request.h b/ios/chrome/browser/payments/test_payment_request.h
index 5aa9e8d..b9d92fb 100644
--- a/ios/chrome/browser/payments/test_payment_request.h
+++ b/ios/chrome/browser/payments/test_payment_request.h
@@ -90,6 +90,11 @@
   // Removes all the payment methods.
   void ClearPaymentMethods();
 
+  // Clears all url payment method identifiers, supported card networks,
+  // basic card specified networks, and supported card types and then resets
+  // them.
+  void ResetParsedPaymentMethodData();
+
   // Sets the currently selected shipping option for this PaymentRequest flow.
   void set_selected_shipping_option(web::PaymentShippingOption* option) {
     selected_shipping_option_ = option;

ios/chrome/browser/payments/test_payment_request.mm

diff --git a/ios/chrome/browser/payments/test_payment_request.mm b/ios/chrome/browser/payments/test_payment_request.mm
index 0ffdd8b..0e22e27f 100644
--- a/ios/chrome/browser/payments/test_payment_request.mm
+++ b/ios/chrome/browser/payments/test_payment_request.mm
@@ -6,6 +6,7 @@
 
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/region_data_loader.h"
+#include "components/payments/core/payment_request_data_util.h"
 #include "components/payments/core/payments_profile_comparator.h"
 #include "components/prefs/pref_service.h"
 #include "ios/web/public/payments/payment_request.h"
@@ -28,6 +29,14 @@
   payment_methods_.clear();
 }
 
+void TestPaymentRequest::ResetParsedPaymentMethodData() {
+  url_payment_method_identifiers_.clear();
+  supported_card_networks_.clear();
+  basic_card_specified_networks_.clear();
+  supported_card_types_set_.clear();
+  PaymentRequest::ParsePaymentMethodData();
+}
+
 AddressNormalizer* TestPaymentRequest::GetAddressNormalizer() {
   return &address_normalizer_;
 }

ios/chrome/browser/sessions/tab_restore_service_delegate_impl_ios.mm

diff --git a/ios/chrome/browser/sessions/tab_restore_service_delegate_impl_ios.mm b/ios/chrome/browser/sessions/tab_restore_service_delegate_impl_ios.mm
index b766c882..a1a03f4 100644
--- a/ios/chrome/browser/sessions/tab_restore_service_delegate_impl_ios.mm
+++ b/ios/chrome/browser/sessions/tab_restore_service_delegate_impl_ios.mm
@@ -16,6 +16,7 @@
 #import "ios/chrome/browser/tabs/tab_model.h"
 #import "ios/chrome/browser/tabs/tab_model_list.h"
 #import "ios/chrome/browser/web_state_list/web_state_list.h"
+#import "ios/chrome/browser/web_state_list/web_state_opener.h"
 #import "ios/web/navigation/navigation_manager_impl.h"
 #include "ios/web/public/navigation_item.h"
 #import "ios/web/web_state/web_state_impl.h"
@@ -89,10 +90,12 @@
   web_state->GetNavigationManagerImpl().ReplaceSessionHistory(
       std::move(items), selected_navigation);
 
-  WebStateList* web_state_list = [tab_model() webStateList];
-  web_state_list->InsertWebState(tab_index, std::move(web_state));
   // TODO(crbug.com/661636): Handle tab-switch animation somehow...
-  web_state_list->ActivateWebStateAt(tab_index);
+  WebStateList* web_state_list = [tab_model() webStateList];
+  web_state_list->InsertWebState(
+      tab_index, std::move(web_state),
+      WebStateList::INSERT_FORCE_INDEX | WebStateList::INSERT_ACTIVATE,
+      WebStateOpener());
   return nullptr;
 }
 

ios/chrome/browser/tabs/tab_model.mm

diff --git a/ios/chrome/browser/tabs/tab_model.mm b/ios/chrome/browser/tabs/tab_model.mm
index f797749b..a8d5088 100644
--- a/ios/chrome/browser/tabs/tab_model.mm
+++ b/ios/chrome/browser/tabs/tab_model.mm
@@ -471,37 +471,38 @@
 
   web::WebState::CreateParams createParams(self.browserState);
   createParams.created_with_opener = openedByDOM;
-  std::unique_ptr<web::WebState> webState = web::WebState::Create(createParams);
 
-  web::WebState* webStatePtr = webState.get();
-  if (index == TabModelConstants::kTabPositionAutomatically) {
-    _webStateList->AppendWebState(loadParams.transition_type,
-                                  std::move(webState),
-                                  WebStateOpener(parentTab.webState));
-  } else {
+  int insertionIndex = WebStateList::kInvalidIndex;
+  int insertionFlags = WebStateList::INSERT_NO_FLAGS;
+  if (index != TabModelConstants::kTabPositionAutomatically) {
     DCHECK_LE(index, static_cast<NSUInteger>(INT_MAX));
-    const int insertion_index = static_cast<int>(index);
-    _webStateList->InsertWebState(insertion_index, std::move(webState));
-    if (parentTab.webState) {
-      _webStateList->SetOpenerOfWebStateAt(insertion_index,
-                                           WebStateOpener(parentTab.webState));
-    }
+    insertionIndex = static_cast<int>(index);
+    insertionFlags |= WebStateList::INSERT_FORCE_INDEX;
+  } else if (!ui::PageTransitionCoreTypeIs(loadParams.transition_type,
+                                           ui::PAGE_TRANSITION_LINK)) {
+    insertionIndex = _webStateList->count();
+    insertionFlags |= WebStateList::INSERT_FORCE_INDEX;
   }
 
-  Tab* tab = LegacyTabHelper::GetTabForWebState(webStatePtr);
+  insertionIndex = _webStateList->InsertWebState(
+      insertionIndex, web::WebState::Create(createParams), insertionFlags,
+      WebStateOpener(parentTab.webState));
+
+  web::WebState* webState = _webStateList->GetWebStateAt(insertionIndex);
+  Tab* tab = LegacyTabHelper::GetTabForWebState(webState);
   DCHECK(tab);
 
-  webStatePtr->SetWebUsageEnabled(_webUsageEnabled ? true : false);
+  webState->SetWebUsageEnabled(_webUsageEnabled ? true : false);
 
   if (!inBackground && _tabUsageRecorder)
     _tabUsageRecorder->TabCreatedForSelection(tab);
 
-  webStatePtr->GetNavigationManager()->LoadURLWithParams(loadParams);
+  webState->GetNavigationManager()->LoadURLWithParams(loadParams);
 
   // Force the page to start loading even if it's in the background.
   // TODO(crbug.com/705819): Remove this call.
   if (_webUsageEnabled)
-    webStatePtr->GetView();
+    webState->GetView();
 
   NSDictionary* userInfo = @{
     kTabModelTabKey : tab,
@@ -512,6 +513,9 @@
                     object:self
                   userInfo:userInfo];
 
+  // TODO(crbug.com/620083): INSERT_ACTIVATE should be set in insertionFlags
+  // if inBackground is YES instead of calling -setCurrentTab: here. As this
+  // requires further refactoring, it will be done in a followup CL.
   if (!inBackground)
     [self setCurrentTab:tab];
 

ios/chrome/browser/tabs/tab_model_unittest.mm

diff --git a/ios/chrome/browser/tabs/tab_model_unittest.mm b/ios/chrome/browser/tabs/tab_model_unittest.mm
index e1131973..a934dae 100644
--- a/ios/chrome/browser/tabs/tab_model_unittest.mm
+++ b/ios/chrome/browser/tabs/tab_model_unittest.mm
@@ -24,6 +24,7 @@
 #import "ios/chrome/browser/tabs/tab_private.h"
 #import "ios/chrome/browser/web/chrome_web_client.h"
 #import "ios/chrome/browser/web_state_list/web_state_list.h"
+#import "ios/chrome/browser/web_state_list/web_state_opener.h"
 #include "ios/chrome/test/ios_chrome_scoped_testing_chrome_browser_state_manager.h"
 #import "ios/web/navigation/navigation_manager_impl.h"
 #import "ios/web/public/crw_session_storage.h"
@@ -1096,7 +1097,9 @@
   Tab* tab = LegacyTabHelper::GetTabForWebState(web_state.get());
   EXPECT_NSEQ(nil, [tab parentTabModel]);
 
-  [tab_model_ webStateList]->InsertWebState(0, std::move(web_state));
+  [tab_model_ webStateList]->InsertWebState(0, std::move(web_state),
+                                            WebStateList::INSERT_FORCE_INDEX,
+                                            WebStateOpener());
   EXPECT_NSEQ(tab_model_, [tab parentTabModel]);
 }
 
@@ -1107,7 +1110,9 @@
   EXPECT_NSEQ(nil, LegacyTabHelper::GetTabForWebState(web_state.get()));
 
   web::WebState* web_state_ptr = web_state.get();
-  [tab_model_ webStateList]->InsertWebState(0, std::move(web_state));
+  [tab_model_ webStateList]->InsertWebState(0, std::move(web_state),
+                                            WebStateList::INSERT_FORCE_INDEX,
+                                            WebStateOpener());
   EXPECT_NSNE(nil, LegacyTabHelper::GetTabForWebState(web_state_ptr));
 }
 

ios/chrome/browser/ui/browser_view_controller.mm

diff --git a/ios/chrome/browser/ui/browser_view_controller.mm b/ios/chrome/browser/ui/browser_view_controller.mm
index fa6869f6..2338cae 100644
--- a/ios/chrome/browser/ui/browser_view_controller.mm
+++ b/ios/chrome/browser/ui/browser_view_controller.mm
@@ -100,6 +100,7 @@
 #import "ios/chrome/browser/ui/bookmarks/bookmark_interaction_controller.h"
 #import "ios/chrome/browser/ui/browser_container_view.h"
 #import "ios/chrome/browser/ui/browser_view_controller_dependency_factory.h"
+#import "ios/chrome/browser/ui/bubble/bubble_view_controller_presenter.h"
 #import "ios/chrome/browser/ui/chrome_web_view_factory.h"
 #import "ios/chrome/browser/ui/commands/UIKit+ChromeExecuteCommand.h"
 #import "ios/chrome/browser/ui/commands/application_commands.h"
@@ -576,6 +577,12 @@
 // ones that cannot be scrolled off screen by full screen.
 @property(nonatomic, strong, readonly) NSArray<HeaderDefinition*>* headerViews;
 
+// Used to display in-product help promotion bubbles. Nil if no bubble has been
+// presented by this view controller yet. Once a presented bubble is dismissed,
+// remains allocated so |userEngaged| remains accessible.
+@property(nonatomic, strong)
+    BubbleViewControllerPresenter* bubbleViewControllerPresenter;
+
 // BVC initialization:
 // If the BVC is initialized with a valid browser state & tab model immediately,
 // the path is straightforward: functionality is enabled, and the UI is built
@@ -673,6 +680,18 @@
 // TODO(crbug.com/522721): Support size changes for all popups and modal
 // dialogs.
 - (void)dismissPopups;
+// Initializes |bubbleViewControllerPresenter|. |feature| is the
+// base::Feature object associated with the given promotion. If
+// feature_engagement::Tracker->ShouldTriggerHelpUI returns |false|, the bubble
+// is not shown. |direction| is the direction the bubble's arrow is pointing.
+// |alignment| is the alignment of the arrow on the button. |anchorPoint| is the
+// point at which the bubble is anchored in window coordinates. |text| is the
+// text displayed by the bubble.
+- (void)presentBubbleForFeature:(const base::Feature&)feature
+                      direction:(BubbleArrowDirection)direction
+                      alignment:(BubbleAlignment)alignment
+                    anchorPoint:(CGPoint)anchorPoint
+                           text:(NSString*)text;
 // Create and show the find bar.
 - (void)initFindBarForTab;
 // Search for find bar query string.
@@ -921,6 +940,7 @@
 @synthesize presenting = _presenting;
 @synthesize foregroundTabWasAddedCompletionBlock =
     _foregroundTabWasAddedCompletionBlock;
+@synthesize bubbleViewControllerPresenter = _bubbleViewControllerPresenter;
 
 #pragma mark - Object lifecycle
 
@@ -1235,6 +1255,26 @@
   [super viewDidAppear:animated];
   self.viewVisible = YES;
   [self updateDialogPresenterActiveState];
+
+  __weak BrowserViewController* weakSelf = self;
+  void (^onInitializedBlock)(bool) = ^(bool successfullyLoaded) {
+    NSString* text =
+        l10n_util::GetNSStringWithFixup(IDS_IOS_NEW_TAB_IPH_PROMOTION_TEXT);
+    CGPoint tabSwitcherAnchor = [weakSelf.toolbarController
+        anchorPointForTabSwitcherButton:BubbleArrowDirectionUp];
+    [weakSelf presentBubbleForFeature:feature_engagement::kIPHNewTabTipFeature
+                            direction:BubbleArrowDirectionUp
+                            alignment:BubbleAlignmentTrailing
+                          anchorPoint:tabSwitcherAnchor
+                                 text:text];
+  };
+
+  // Because the new tab tip occurs on startup, the feature engagement tracker's
+  // database is not guaranteed to be loaded by this time. For the bubble to
+  // appear properly, a callback is used to guarantee the event data is loaded
+  // before the check to see if the promotion should be displayed.
+  feature_engagement::TrackerFactory::GetForBrowserState(self.browserState)
+      ->AddOnInitializedCallback(base::BindBlockArc(onInitializedBlock));
 }
 
 - (void)viewWillAppear:(BOOL)animated {
@@ -1955,6 +1995,41 @@
   [_toolbarController dismissToolsMenuPopup];
   [self hidePageInfoPopupForView:nil];
   [_toolbarController dismissTabHistoryPopup];
+  [self.bubbleViewControllerPresenter dismissAnimated:YES];
+}
+
+- (void)presentBubbleForFeature:(const base::Feature&)feature
+                      direction:(BubbleArrowDirection)direction
+                      alignment:(BubbleAlignment)alignment
+                    anchorPoint:(CGPoint)anchorPoint
+                           text:(NSString*)text {
+  if (!feature_engagement::TrackerFactory::GetForBrowserState(_browserState)
+           ->ShouldTriggerHelpUI(feature)) {
+    return;
+  }
+  // Capture |weakSelf| instead of the feature engagement tracker object
+  // because |weakSelf| will safely become |nil| if it is deallocated, whereas
+  // the feature engagement tracker will remain pointing to invalid memory if
+  // its owner (the ChromeBrowserState) is deallocated.
+  __weak BrowserViewController* weakSelf = self;
+  void (^dismissalCallback)(void) = ^() {
+    BrowserViewController* strongSelf = weakSelf;
+    if (strongSelf) {
+      feature_engagement::TrackerFactory::GetForBrowserState(
+          strongSelf.browserState)
+          ->Dismissed(feature);
+    }
+  };
+
+  self.bubbleViewControllerPresenter =
+      [[BubbleViewControllerPresenter alloc] initWithText:text
+                                           arrowDirection:direction
+                                                alignment:alignment
+                                        dismissalCallback:dismissalCallback];
+
+  [self.bubbleViewControllerPresenter presentInViewController:self
+                                                         view:self.view
+                                                  anchorPoint:anchorPoint];
 }
 
 #pragma mark - Tap handling
@@ -4268,6 +4343,7 @@
   [_toolbarController cancelOmniboxEdit];
   [_dialogPresenter cancelAllDialogs];
   [self hidePageInfoPopupForView:nil];
+  [self.bubbleViewControllerPresenter dismissAnimated:NO];
   if (_voiceSearchController)
     _voiceSearchController->DismissMicPermissionsHelp();
 

ios/chrome/browser/ui/bubble/BUILD.gn

diff --git a/ios/chrome/browser/ui/bubble/BUILD.gn b/ios/chrome/browser/ui/bubble/BUILD.gn
index 2266f80..c62cf399 100644
--- a/ios/chrome/browser/ui/bubble/BUILD.gn
+++ b/ios/chrome/browser/ui/bubble/BUILD.gn
@@ -12,6 +12,8 @@
     "bubble_view_anchor_point_provider.h",
     "bubble_view_controller.h",
     "bubble_view_controller.mm",
+    "bubble_view_controller_presenter.h",
+    "bubble_view_controller_presenter.mm",
   ]
   deps = [
     "//base",
@@ -29,6 +31,7 @@
   testonly = true
   sources = [
     "bubble_util_unittest.mm",
+    "bubble_view_controller_presenter_unittest.mm",
     "bubble_view_unittest.mm",
   ]
   deps = [
@@ -37,4 +40,5 @@
     "//base:i18n",
     "//testing/gtest",
   ]
+  libs = [ "CoreGraphics.framework" ]
 }

ios/chrome/browser/ui/bubble/bubble_view_controller_presenter.h

diff --git a/ios/chrome/browser/ui/bubble/bubble_view_controller_presenter.h b/ios/chrome/browser/ui/bubble/bubble_view_controller_presenter.h
new file mode 100644
index 0000000..4db25936
--- /dev/null
+++ b/ios/chrome/browser/ui/bubble/bubble_view_controller_presenter.h
@@ -0,0 +1,62 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef IOS_CHROME_BROWSER_UI_BUBBLE_BUBBLE_VIEW_CONTROLLER_PRESENTER_H_
+#define IOS_CHROME_BROWSER_UI_BUBBLE_BUBBLE_VIEW_CONTROLLER_PRESENTER_H_
+
+#import <UIKit/UIKit.h>
+
+#import "base/ios/block_types.h"
+#import "ios/chrome/browser/ui/bubble/bubble_view.h"
+
+@class BubbleViewController;
+
+// Encapsulates all functionality necessary to interact with a BubbleView
+// object. Manages the underlying BubbleViewController, dismissal by timer,
+// dismissal by tap gesture (inside or outside the bubble), and whether the user
+// should be considered engaged with the bubble.
+@interface BubbleViewControllerPresenter : NSObject
+
+// Determines whether the user is still engaged with the bubble view. Defaults
+// to |YES|. After a certain duration of time, is set to |NO| automatically.
+// Used to determine whether the bubble has influenced the user's
+// action. For example, if a bubble appears pointing at the tab switcher button,
+// and the user taps the tab switcher button shortly after, |userEngaged| would
+// be |YES| because the user has recently seen the bubble and can reasonably be
+// assumed to be influenced by it. However, if a bubble appears in the same
+// scenario, but the user ignores it and doesn't click the tab switcher button
+// until significantly later, |userEngaged| will be |NO| because it is unlikely
+// the bubble had an effect on the user's action.
+@property(nonatomic, assign, readonly, getter=isUserEngaged) BOOL userEngaged;
+
+// Initializes the presenter. |text| is the text displayed by the bubble.
+// |arrowDirection| is the direction the bubble's arrow is pointing. |alignment|
+// is the position of the arrow on the bubble. |dismissalCallback| is a block
+// invoked when the bubble is dismissed (manual and automatic dismissal).
+// |dismissalCallback| is optional.
+- (instancetype)initWithText:(NSString*)text
+              arrowDirection:(BubbleArrowDirection)arrowDirection
+                   alignment:(BubbleAlignment)alignment
+           dismissalCallback:(ProceduralBlock)dismissalCallback
+    NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+// Presents the bubble in |parentView|. The underlying BubbleViewController is
+// added as a child view controller of |parentViewController|. |anchorPoint|
+// determines where the bubble is anchored in window coordinates.
+- (void)presentInViewController:(UIViewController*)parentViewController
+                           view:(UIView*)parentView
+                    anchorPoint:(CGPoint)anchorPoint;
+
+// Removes the bubble from the screen and removes the BubbleViewController from
+// its parent. If the bubble is not visible, has no effect. Can be animated or
+// not. Invokes the dismissal callback. The callback is invoked immediately
+// regardless of the value of |animated|. It does not wait for the animation
+// to complete if |animated| is |YES|.
+- (void)dismissAnimated:(BOOL)animated;
+
+@end
+
+#endif  // IOS_CHROME_BROWSER_UI_BUBBLE_BUBBLE_VIEW_CONTROLLER_PRESENTER_H_

ios/chrome/browser/ui/bubble/bubble_view_controller_presenter.mm

diff --git a/ios/chrome/browser/ui/bubble/bubble_view_controller_presenter.mm b/ios/chrome/browser/ui/bubble/bubble_view_controller_presenter.mm
new file mode 100644
index 0000000..cb298b0
--- /dev/null
+++ b/ios/chrome/browser/ui/bubble/bubble_view_controller_presenter.mm
@@ -0,0 +1,232 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#import "ios/chrome/browser/ui/bubble/bubble_view_controller_presenter.h"
+
+#import "base/ios/block_types.h"
+#include "base/logging.h"
+#include "ios/chrome/browser/ui/bubble/bubble_util.h"
+#import "ios/chrome/browser/ui/bubble/bubble_view_controller.h"
+
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
+namespace {
+
+// How long, in seconds, the bubble is visible on the screen.
+const NSTimeInterval kBubbleVisibilityDuration = 3.0;
+// How long, in seconds, the user should be considered engaged with the bubble
+// after the bubble first becomes visible.
+const NSTimeInterval kBubbleEngagementDuration = 30.0;
+
+}  // namespace
+
+@interface BubbleViewControllerPresenter ()<UIGestureRecognizerDelegate>
+
+// Redeclared as readwrite so the value can be changed internally.
+@property(nonatomic, assign, readwrite, getter=isUserEngaged) BOOL userEngaged;
+// The underlying BubbleViewController managed by this object.
+// |bubbleViewController| manages the BubbleView instance.
+@property(nonatomic, strong) BubbleViewController* bubbleViewController;
+// The tap gesture recognizer intercepting tap gestures occurring inside the
+// bubble view. Taps inside must be differentiated from taps outside to track
+// UMA metrics.
+@property(nonatomic, strong) UITapGestureRecognizer* insideBubbleTapRecognizer;
+// The tap gesture recognizer intercepting tap gestures occurring outside the
+// bubble view. Does not prevent interactions with elements being tapped on.
+// For example, tapping on a button both dismisses the bubble and triggers the
+// button's action.
+@property(nonatomic, strong) UITapGestureRecognizer* outsideBubbleTapRecognizer;
+// The timer used to dismiss the bubble after a certain length of time. The
+// bubble is dismissed automatically if the user does not dismiss it manually.
+// If the user dismisses it manually, this timer is invalidated. The timer
+// maintains a strong reference to the presenter, so it must be retained weakly
+// to prevent a retain cycle. The run loop retains a strong reference to the
+// timer so it is not deallocated until it is invalidated.
+@property(nonatomic, weak) NSTimer* bubbleDismissalTimer;
+// The timer used to reset the user's engagement. The user is considered
+// engaged with the bubble while it is visible and for a certain duration after
+// it disappears. The timer maintains a strong reference to the presenter, so it
+// must be retained weakly to prevent a retain cycle. The run loop retains a
+// strong reference to the timer so it is not deallocated until it is
+// invalidated.
+@property(nonatomic, weak) NSTimer* engagementTimer;
+// The direction the underlying BubbleView's arrow is pointing.
+@property(nonatomic, assign) BubbleArrowDirection arrowDirection;
+// The alignment of the underlying BubbleView's arrow.
+@property(nonatomic, assign) BubbleAlignment alignment;
+// The block invoked when the bubble is dismissed (both via timer and via tap).
+// Is optional.
+@property(nonatomic, strong) ProceduralBlock dismissalCallback;
+
+@end
+
+@implementation BubbleViewControllerPresenter
+
+@synthesize bubbleViewController = _bubbleViewController;
+@synthesize insideBubbleTapRecognizer = _insideBubbleTapRecognizer;
+@synthesize outsideBubbleTapRecognizer = _outsideBubbleTapRecognizer;
+@synthesize bubbleDismissalTimer = _bubbleDismissalTimer;
+@synthesize engagementTimer = _engagementTimer;
+@synthesize userEngaged = _userEngaged;
+@synthesize arrowDirection = _arrowDirection;
+@synthesize alignment = _alignment;
+@synthesize dismissalCallback = _dismissalCallback;
+
+- (instancetype)initWithText:(NSString*)text
+              arrowDirection:(BubbleArrowDirection)arrowDirection
+                   alignment:(BubbleAlignment)alignment
+           dismissalCallback:(ProceduralBlock)dismissalCallback {
+  self = [super init];
+  if (self) {
+    _bubbleViewController =
+        [[BubbleViewController alloc] initWithText:text
+                                    arrowDirection:arrowDirection
+                                         alignment:alignment];
+    _outsideBubbleTapRecognizer = [[UITapGestureRecognizer alloc]
+        initWithTarget:self
+                action:@selector(tapOutsideBubbleRecognized:)];
+    _outsideBubbleTapRecognizer.delegate = self;
+    _outsideBubbleTapRecognizer.cancelsTouchesInView = NO;
+    _insideBubbleTapRecognizer = [[UITapGestureRecognizer alloc]
+        initWithTarget:self
+                action:@selector(tapInsideBubbleRecognized:)];
+    _insideBubbleTapRecognizer.delegate = self;
+    _insideBubbleTapRecognizer.cancelsTouchesInView = NO;
+    _userEngaged = NO;
+    _arrowDirection = arrowDirection;
+    _alignment = alignment;
+    _dismissalCallback = dismissalCallback;
+    // The timers are initialized when the bubble is presented, not during
+    // initialization. Because the user might not present the bubble immediately
+    // after initialization, the timers cannot be started until the bubble
+    // appears on screen.
+  }
+  return self;
+}
+
+- (void)presentInViewController:(UIViewController*)parentViewController
+                           view:(UIView*)parentView
+                    anchorPoint:(CGPoint)anchorPoint {
+  [parentViewController addChildViewController:self.bubbleViewController];
+
+  CGPoint anchorPointInParent =
+      [parentView.window convertPoint:anchorPoint toView:parentView];
+  self.bubbleViewController.view.frame =
+      [self frameForBubbleInRect:parentView.bounds
+                   atAnchorPoint:anchorPointInParent];
+  [parentView addSubview:self.bubbleViewController.view];
+  [self.bubbleViewController animateContentIn];
+
+  [self.bubbleViewController.view
+      addGestureRecognizer:self.insideBubbleTapRecognizer];
+  [parentView addGestureRecognizer:self.outsideBubbleTapRecognizer];
+
+  self.bubbleDismissalTimer = [NSTimer
+      scheduledTimerWithTimeInterval:kBubbleVisibilityDuration
+                              target:self
+                            selector:@selector(bubbleDismissalTimerFired:)
+                            userInfo:nil
+                             repeats:NO];
+
+  self.userEngaged = YES;
+  self.engagementTimer =
+      [NSTimer scheduledTimerWithTimeInterval:kBubbleEngagementDuration
+                                       target:self
+                                     selector:@selector(engagementTimerFired:)
+                                     userInfo:nil
+                                      repeats:NO];
+}
+
+- (void)dismissAnimated:(BOOL)animated {
+  // Because this object must stay in memory to handle the |userEngaged|
+  // property correctly, it is possible for |dismissAnimated| to be called
+  // multiple times. However, only the first call should have any effect.
+  if (!self.bubbleViewController.parentViewController) {
+    return;
+  }
+
+  [self.bubbleDismissalTimer invalidate];
+  self.bubbleDismissalTimer = nil;
+  [self.insideBubbleTapRecognizer.view
+      removeGestureRecognizer:self.insideBubbleTapRecognizer];
+  [self.outsideBubbleTapRecognizer.view
+      removeGestureRecognizer:self.outsideBubbleTapRecognizer];
+  [self.bubbleViewController dismissAnimated:animated];
+  [self.bubbleViewController willMoveToParentViewController:nil];
+  [self.bubbleViewController removeFromParentViewController];
+
+  if (self.dismissalCallback) {
+    self.dismissalCallback();
+  }
+}
+
+- (void)dealloc {
+  [self.bubbleDismissalTimer invalidate];
+  self.bubbleDismissalTimer = nil;
+  [self.engagementTimer invalidate];
+  self.engagementTimer = nil;
+  [self.insideBubbleTapRecognizer.view
+      removeGestureRecognizer:self.insideBubbleTapRecognizer];
+  [self.outsideBubbleTapRecognizer.view
+      removeGestureRecognizer:self.outsideBubbleTapRecognizer];
+}
+
+#pragma mark - UIGestureRecognizerDelegate
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer*)gestureRecognizer
+    shouldRecognizeSimultaneouslyWithGestureRecognizer:
+        (UIGestureRecognizer*)otherGestureRecognizer {
+  // Because the outside tap recognizer is potentially in the responder chain,
+  // this prevents both the inside and outside gesture recognizers from
+  // triggering at once when tapping inside the bubble.
+  return gestureRecognizer != self.insideBubbleTapRecognizer &&
+         otherGestureRecognizer != self.insideBubbleTapRecognizer;
+}
+
+#pragma mark - Private
+
+// Invoked by tapping inside the bubble. Dismisses the bubble.
+- (void)tapInsideBubbleRecognized:(id)sender {
+  [self dismissAnimated:YES];
+}
+
+// Invoked by tapping outside the bubble. Dismisses the bubble.
+- (void)tapOutsideBubbleRecognized:(id)sender {
+  [self dismissAnimated:YES];
+}
+
+// Automatically dismisses the bubble view when |bubbleDismissalTimer| fires.
+- (void)bubbleDismissalTimerFired:(id)sender {
+  [self dismissAnimated:YES];
+}
+
+// Marks the user as not engaged when |engagementTimer| fires.
+- (void)engagementTimerFired:(id)sender {
+  self.userEngaged = NO;
+  self.engagementTimer = nil;
+}
+
+// Calculates the frame of the BubbleView. |rect| is the frame of the bubble's
+// superview. |anchorPoint| is the anchor point of the bubble. |anchorPoint|
+// and |rect| must be in the same coordinates.
+- (CGRect)frameForBubbleInRect:(CGRect)rect atAnchorPoint:(CGPoint)anchorPoint {
+  CGSize maxBubbleSize = bubble_util::BubbleMaxSize(
+      anchorPoint, self.arrowDirection, self.alignment, rect.size);
+  CGSize bubbleSize =
+      [self.bubbleViewController.view sizeThatFits:maxBubbleSize];
+  // If |bubbleSize| does not fit in |maxBubbleSize|, the bubble will be
+  // partially off screen and not look good. This is most likely a result of
+  // an incorrect value for |alignment| (such as a trailing aligned bubble
+  // anchored to an element on the leading edge of the screen).
+  DCHECK(bubbleSize.width <= maxBubbleSize.width);
+  DCHECK(bubbleSize.height <= maxBubbleSize.height);
+  CGRect bubbleFrame =
+      bubble_util::BubbleFrame(anchorPoint, bubbleSize, self.arrowDirection,
+                               self.alignment, CGRectGetWidth(rect));
+  return bubbleFrame;
+}
+
+@end

ios/chrome/browser/ui/bubble/bubble_view_controller_presenter_unittest.mm

diff --git a/ios/chrome/browser/ui/bubble/bubble_view_controller_presenter_unittest.mm b/ios/chrome/browser/ui/bubble/bubble_view_controller_presenter_unittest.mm
new file mode 100644
index 0000000..62215dcd
--- /dev/null
+++ b/ios/chrome/browser/ui/bubble/bubble_view_controller_presenter_unittest.mm
@@ -0,0 +1,186 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#import <UIKit/UIKit.h>
+
+#import "ios/chrome/browser/ui/bubble/bubble_view.h"
+#import "ios/chrome/browser/ui/bubble/bubble_view_controller.h"
+#import "ios/chrome/browser/ui/bubble/bubble_view_controller_presenter.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/platform_test.h"
+
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
+@interface BubbleViewControllerPresenter (Testing)
+
+// Underlying bubble view controller managed by the presenter.
+@property(nonatomic, strong) BubbleViewController* bubbleViewController;
+
+// Underlying timer used to dismiss the bubble automatically.
+@property(nonatomic, strong) NSTimer* bubbleDismissalTimer;
+
+// Underlying timer used to mark the user as no longer engaged automatically.
+@property(nonatomic, strong) NSTimer* engagementTimer;
+
+@end
+
+// Test fixture to test the BubbleViewControllerPresenter.
+class BubbleViewControllerPresenterTest : public PlatformTest {
+ public:
+  BubbleViewControllerPresenterTest()
+      : bubbleViewControllerPresenter_([[BubbleViewControllerPresenter alloc]
+                 initWithText:@"Text"
+               arrowDirection:BubbleArrowDirectionUp
+                    alignment:BubbleAlignmentCenter
+            dismissalCallback:^() {
+              dismissalCallbackCount_++;
+            }]),
+        window_([[UIWindow alloc]
+            initWithFrame:CGRectMake(0.0, 0.0, 500.0, 500.0)]),
+        parentViewController_([[UIViewController alloc] init]),
+        anchorPoint_(CGPointMake(250.0, 250.0)),
+        dismissalCallbackCount_(0) {
+    parentViewController_.view.frame = CGRectMake(0.0, 0.0, 500.0, 500.0);
+    [window_ addSubview:parentViewController_.view];
+  }
+
+ protected:
+  // The presenter object under test.
+  BubbleViewControllerPresenter* bubbleViewControllerPresenter_;
+  // The window the |parentViewController_|'s view is in.
+  // -presentInViewController: expects the |anchorPoint| parameter to be in
+  // window coordinates, which requires the |view| property to be in a window.
+  UIWindow* window_;
+  // The view controller the BubbleViewController is added as a child of.
+  UIViewController* parentViewController_;
+  // The point at which the bubble is anchored.
+  CGPoint anchorPoint_;
+  // How many times |bubbleViewControllerPresenter_|'s internal
+  // |dismissalCallback| has been invoked. Defaults to 0. Every time the
+  // callback is invoked, |dismissalCallbackCount_| increments.
+  int dismissalCallbackCount_;
+};
+
+// Tests that, after initialization, the internal BubbleViewController and
+// BubbleView have not been added to the parent.
+TEST_F(BubbleViewControllerPresenterTest, InitializedNotAdded) {
+  EXPECT_FALSE([parentViewController_.childViewControllers
+      containsObject:bubbleViewControllerPresenter_.bubbleViewController]);
+  EXPECT_FALSE([parentViewController_.view.subviews
+      containsObject:bubbleViewControllerPresenter_.bubbleViewController.view]);
+}
+
+// Tests that -presentInViewController: adds the BubbleViewController and
+// BubbleView to the parent.
+TEST_F(BubbleViewControllerPresenterTest, PresentAddsToViewController) {
+  [bubbleViewControllerPresenter_
+      presentInViewController:parentViewController_
+                         view:parentViewController_.view
+                  anchorPoint:anchorPoint_];
+  EXPECT_TRUE([parentViewController_.childViewControllers
+      containsObject:bubbleViewControllerPresenter_.bubbleViewController]);
+  EXPECT_TRUE([parentViewController_.view.subviews
+      containsObject:bubbleViewControllerPresenter_.bubbleViewController.view]);
+}
+
+// Tests that initially the dismissal callback has not been invoked.
+TEST_F(BubbleViewControllerPresenterTest, DismissalCallbackCountInitialized) {
+  EXPECT_EQ(0, dismissalCallbackCount_);
+}
+
+// Tests that presenting the bubble but not dismissing it does not invoke the
+// dismissal callback.
+TEST_F(BubbleViewControllerPresenterTest, DismissalCallbackNotCalled) {
+  [bubbleViewControllerPresenter_
+      presentInViewController:parentViewController_
+                         view:parentViewController_.view
+                  anchorPoint:anchorPoint_];
+  EXPECT_EQ(0, dismissalCallbackCount_);
+}
+
+// Tests that presenting then dismissing the bubble invokes the dismissal
+// callback.
+TEST_F(BubbleViewControllerPresenterTest, DismissalCallbackCalledOnce) {
+  [bubbleViewControllerPresenter_
+      presentInViewController:parentViewController_
+                         view:parentViewController_.view
+                  anchorPoint:anchorPoint_];
+  [bubbleViewControllerPresenter_ dismissAnimated:NO];
+  EXPECT_EQ(1, dismissalCallbackCount_);
+}
+
+// Tests that calling -dismissAnimated: after the bubble has already been
+// dismissed does not invoke the dismissal callback again.
+TEST_F(BubbleViewControllerPresenterTest, DismissalCallbackNotCalledTwice) {
+  [bubbleViewControllerPresenter_
+      presentInViewController:parentViewController_
+                         view:parentViewController_.view
+                  anchorPoint:anchorPoint_];
+  [bubbleViewControllerPresenter_ dismissAnimated:NO];
+  [bubbleViewControllerPresenter_ dismissAnimated:NO];
+  EXPECT_EQ(1, dismissalCallbackCount_);
+}
+
+// Tests that calling -dismissAnimated: before the bubble has been presented
+// does not invoke the dismissal callback.
+TEST_F(BubbleViewControllerPresenterTest,
+       DismissalCallbackNotCalledBeforePresentation) {
+  [bubbleViewControllerPresenter_ dismissAnimated:NO];
+  EXPECT_EQ(0, dismissalCallbackCount_);
+}
+
+// Tests that the timers are |nil| before the bubble is presented on screen.
+TEST_F(BubbleViewControllerPresenterTest, TimersInitiallyNil) {
+  EXPECT_EQ(nil, bubbleViewControllerPresenter_.bubbleDismissalTimer);
+  EXPECT_EQ(nil, bubbleViewControllerPresenter_.engagementTimer);
+}
+
+// Tests that the timers are not |nil| once the bubble is presented on screen.
+TEST_F(BubbleViewControllerPresenterTest, TimersInstantiatedOnPresent) {
+  [bubbleViewControllerPresenter_
+      presentInViewController:parentViewController_
+                         view:parentViewController_.view
+                  anchorPoint:anchorPoint_];
+  EXPECT_NE(nil, bubbleViewControllerPresenter_.bubbleDismissalTimer);
+  EXPECT_NE(nil, bubbleViewControllerPresenter_.engagementTimer);
+}
+
+// Tests that the bubble timer is |nil| but the engagement timer is not |nil|
+// when the bubble is presented and dismissed.
+TEST_F(BubbleViewControllerPresenterTest, BubbleTimerNilOnDismissal) {
+  [bubbleViewControllerPresenter_
+      presentInViewController:parentViewController_
+                         view:parentViewController_.view
+                  anchorPoint:anchorPoint_];
+  [bubbleViewControllerPresenter_ dismissAnimated:NO];
+  EXPECT_EQ(nil, bubbleViewControllerPresenter_.bubbleDismissalTimer);
+  EXPECT_NE(nil, bubbleViewControllerPresenter_.engagementTimer);
+}
+
+// Tests that the |userEngaged| property is initially |NO|.
+TEST_F(BubbleViewControllerPresenterTest, UserEngagedInitiallyNo) {
+  EXPECT_FALSE(bubbleViewControllerPresenter_.isUserEngaged);
+}
+
+// Tests that the |userEngaged| property is |YES| once the bubble is presented
+// on screen.
+TEST_F(BubbleViewControllerPresenterTest, UserEngagedYesOnPresent) {
+  [bubbleViewControllerPresenter_
+      presentInViewController:parentViewController_
+                         view:parentViewController_.view
+                  anchorPoint:anchorPoint_];
+  EXPECT_TRUE(bubbleViewControllerPresenter_.isUserEngaged);
+}
+
+// Tests that the |userEngaged| property remains |YES| once the bubble is
+// presented and dismissed.
+TEST_F(BubbleViewControllerPresenterTest, UserEngagedYesOnDismissal) {
+  [bubbleViewControllerPresenter_
+      presentInViewController:parentViewController_
+                         view:parentViewController_.view
+                  anchorPoint:anchorPoint_];
+  EXPECT_TRUE(bubbleViewControllerPresenter_.isUserEngaged);
+}

ios/chrome/browser/ui/contextual_search/contextual_search_wrangler.mm

diff --git a/ios/chrome/browser/ui/contextual_search/contextual_search_wrangler.mm b/ios/chrome/browser/ui/contextual_search/contextual_search_wrangler.mm
index e14f84ff..449c24c74 100644
--- a/ios/chrome/browser/ui/contextual_search/contextual_search_wrangler.mm
+++ b/ios/chrome/browser/ui/contextual_search/contextual_search_wrangler.mm
@@ -138,9 +138,9 @@
     DCHECK_NE(webStateList->active_index(), WebStateList::kInvalidIndex);
     DCHECK_NE(webStateList->active_index(), INT_MAX);
     int insertion_index = webStateList->active_index() + 1;
-    webStateList->InsertWebState(insertion_index, std::move(webState));
-    webStateList->SetOpenerOfWebStateAt(insertion_index,
-                                        [tabProvider webStateOpener]);
+    webStateList->InsertWebState(insertion_index, std::move(webState),
+                                 WebStateList::INSERT_FORCE_INDEX,
+                                 WebStateOpener([tabProvider webStateOpener]));
 
     // Set isPrerenderTab to NO after inserting the tab. This will allow the
     // BrowserViewController to detect that a pre-rendered tab is switched in,

ios/chrome/browser/ui/ntp/new_tab_page_egtest.mm

diff --git a/ios/chrome/browser/ui/ntp/new_tab_page_egtest.mm b/ios/chrome/browser/ui/ntp/new_tab_page_egtest.mm
index 5e9afa3..a706f20 100644
--- a/ios/chrome/browser/ui/ntp/new_tab_page_egtest.mm
+++ b/ios/chrome/browser/ui/ntp/new_tab_page_egtest.mm
@@ -283,12 +283,10 @@
     EARL_GREY_TEST_SKIPPED(@"Skipped for iPad (no hidden toolbar in tablet)");
   }
 
-  NSString* toolsMenuLabel = l10n_util::GetNSString(IDS_IOS_TOOLBAR_SETTINGS);
-
   // Check that the toolbar's tab switcher and tools menu buttons are visible.
   [[EarlGrey selectElementWithMatcher:chrome_test_util::ShowTabsButton()]
       assertWithMatcher:grey_sufficientlyVisible()];
-  [[EarlGrey selectElementWithMatcher:grey_accessibilityLabel(toolsMenuLabel)]
+  [[EarlGrey selectElementWithMatcher:chrome_test_util::ToolsMenuButton()]
       assertWithMatcher:grey_sufficientlyVisible()];
   AssertNTPScrolledToTop(NO);
 
@@ -301,7 +299,7 @@
   // Check that tab switcher and tools menu buttons are not on screen.
   [[EarlGrey selectElementWithMatcher:chrome_test_util::ShowTabsButton()]
       assertWithMatcher:grey_notVisible()];
-  [[EarlGrey selectElementWithMatcher:grey_accessibilityLabel(toolsMenuLabel)]
+  [[EarlGrey selectElementWithMatcher:chrome_test_util::ToolsMenuButton()]
       assertWithMatcher:grey_notVisible()];
 }
 

ios/chrome/browser/ui/omnibox_perftest.mm

diff --git a/ios/chrome/browser/ui/omnibox_perftest.mm b/ios/chrome/browser/ui/omnibox_perftest.mm
index 3f76fa3..cce6aabb 100644
--- a/ios/chrome/browser/ui/omnibox_perftest.mm
+++ b/ios/chrome/browser/ui/omnibox_perftest.mm
@@ -19,6 +19,7 @@
 #import "ios/chrome/browser/ui/toolbar/web_toolbar_controller.h"
 #include "ios/chrome/browser/web_state_list/fake_web_state_list_delegate.h"
 #include "ios/chrome/browser/web_state_list/web_state_list.h"
+#import "ios/chrome/browser/web_state_list/web_state_opener.h"
 #include "ios/chrome/test/base/perf_test_ios.h"
 #include "ios/web/public/test/fakes/test_navigation_manager.h"
 #include "ios/web/public/test/fakes/test_web_state.h"
@@ -84,7 +85,9 @@
     std::unique_ptr<web::TestNavigationManager> navigation_manager =
         base::MakeUnique<web::TestNavigationManager>();
     web_state->SetNavigationManager(std::move(navigation_manager));
-    web_state_list_->InsertWebState(0, std::move(web_state));
+    web_state_list_->InsertWebState(0, std::move(web_state),
+                                    WebStateList::INSERT_FORCE_INDEX,
+                                    WebStateOpener());
 
     // Creates the Toolbar for testing and sizes it to the width of the screen.
     toolbar_model_delegate_.reset(

ios/chrome/browser/ui/payments/BUILD.gn

diff --git a/ios/chrome/browser/ui/payments/BUILD.gn b/ios/chrome/browser/ui/payments/BUILD.gn
index 7a291e8..bb985a67 100644
--- a/ios/chrome/browser/ui/payments/BUILD.gn
+++ b/ios/chrome/browser/ui/payments/BUILD.gn
@@ -236,6 +236,7 @@
     "//base",
     "//components/autofill/core/browser",
     "//components/autofill/core/browser:test_support",
+    "//components/image_fetcher/core",
     "//components/payments/core",
     "//components/strings",
     "//ios/chrome/app:app_internal",

ios/chrome/browser/ui/payments/payment_method_selection_mediator.mm

diff --git a/ios/chrome/browser/ui/payments/payment_method_selection_mediator.mm b/ios/chrome/browser/ui/payments/payment_method_selection_mediator.mm
index f1362e3a..5c5337a2 100644
--- a/ios/chrome/browser/ui/payments/payment_method_selection_mediator.mm
+++ b/ios/chrome/browser/ui/payments/payment_method_selection_mediator.mm
@@ -15,6 +15,7 @@
 #include "components/payments/core/payment_instrument.h"
 #include "components/payments/core/strings_util.h"
 #include "components/strings/grit/components_strings.h"
+#include "ios/chrome/browser/payments/ios_payment_instrument.h"
 #include "ios/chrome/browser/payments/payment_request.h"
 #include "ios/chrome/browser/payments/payment_request_util.h"
 #import "ios/chrome/browser/ui/payments/cells/payment_method_item.h"
@@ -111,21 +112,29 @@
         *paymentMethod, _paymentRequest->billing_profiles());
     item.complete = paymentMethod->IsCompleteForPayment();
 
-    if (paymentMethod->type() == payments::PaymentInstrument::Type::AUTOFILL) {
-      payments::AutofillPaymentInstrument* autofillInstrument =
-          static_cast<payments::AutofillPaymentInstrument*>(paymentMethod);
-      autofill::AutofillProfile* billingAddress =
-          autofill::PersonalDataManager::GetProfileFromProfilesByGUID(
-              autofillInstrument->credit_card()->billing_address_id(),
-              _paymentRequest->billing_profiles());
-      if (billingAddress) {
-        item.methodAddress =
-            GetBillingAddressLabelFromAutofillProfile(*billingAddress);
+    switch (paymentMethod->type()) {
+      case payments::PaymentInstrument::Type::AUTOFILL: {
+        payments::AutofillPaymentInstrument* autofillInstrument =
+            static_cast<payments::AutofillPaymentInstrument*>(paymentMethod);
+        autofill::AutofillProfile* billingAddress =
+            autofill::PersonalDataManager::GetProfileFromProfilesByGUID(
+                autofillInstrument->credit_card()->billing_address_id(),
+                _paymentRequest->billing_profiles());
+        if (billingAddress) {
+          item.methodAddress =
+              GetBillingAddressLabelFromAutofillProfile(*billingAddress);
+        }
+        item.methodTypeIcon = NativeImage(paymentMethod->icon_resource_id());
+        break;
+      }
+      case payments::PaymentInstrument::Type::NATIVE_MOBILE_APP: {
+        payments::IOSPaymentInstrument* mobileApp =
+            static_cast<payments::IOSPaymentInstrument*>(paymentMethod);
+        item.methodTypeIcon = mobileApp->icon_image();
+        break;
       }
     }
 
-    item.methodTypeIcon = NativeImage(paymentMethod->icon_resource_id());
-
     item.reserveRoomForAccessoryType = YES;
     if (_paymentRequest->selected_payment_method() == paymentMethod)
       _selectedItemIndex = index;

ios/chrome/browser/ui/payments/payment_request_coordinator.h

diff --git a/ios/chrome/browser/ui/payments/payment_request_coordinator.h b/ios/chrome/browser/ui/payments/payment_request_coordinator.h
index 81b0330..e54f905 100644
--- a/ios/chrome/browser/ui/payments/payment_request_coordinator.h
+++ b/ios/chrome/browser/ui/payments/payment_request_coordinator.h
@@ -115,6 +115,10 @@
 // Whether or not the PaymentRequest view controller is in a pending state.
 @property(nonatomic, assign, getter=isPending) BOOL pending;
 
+// Whether or not the user can cancel out of the Payment Request view
+// controller.
+@property(nonatomic, assign, getter=isCancellable) BOOL cancellable;
+
 // The delegate to be notified when the user confirms or cancels the request.
 @property(nonatomic, weak) id<PaymentRequestCoordinatorDelegate> delegate;
 

ios/chrome/browser/ui/payments/payment_request_coordinator.mm

diff --git a/ios/chrome/browser/ui/payments/payment_request_coordinator.mm b/ios/chrome/browser/ui/payments/payment_request_coordinator.mm
index 8570695..f417e5dc 100644
--- a/ios/chrome/browser/ui/payments/payment_request_coordinator.mm
+++ b/ios/chrome/browser/ui/payments/payment_request_coordinator.mm
@@ -63,6 +63,7 @@
 @synthesize pageHost = _pageHost;
 @synthesize connectionSecure = _connectionSecure;
 @synthesize pending = _pending;
+@synthesize cancellable = _cancellable;
 @synthesize delegate = _delegate;
 
 - (void)start {
@@ -74,6 +75,8 @@
   [_viewController setPageTitle:_pageTitle];
   [_viewController setPageHost:_pageHost];
   [_viewController setConnectionSecure:_connectionSecure];
+  [_viewController setPending:!_paymentRequest->payment_instruments_ready()];
+  [_viewController setCancellable:YES];
   [_viewController setDelegate:self];
   [_viewController setDataSource:_mediator];
   [_viewController loadModel];
@@ -123,13 +126,17 @@
 
 - (void)setPending:(BOOL)pending {
   _pending = pending;
-  _viewController.view.userInteractionEnabled = !pending;
   [_viewController setPending:pending];
   [_viewController loadModel];
   [[_viewController collectionView] reloadData];
 }
 
-#pragma mark - Public methods
+- (void)setCancellable:(BOOL)cancellable {
+  _cancellable = cancellable;
+  [_viewController setCancellable:cancellable];
+}
+
+#pragma mark - Public Methods
 
 - (void)
 requestFullCreditCard:(const autofill::CreditCard&)card

ios/chrome/browser/ui/payments/payment_request_manager.mm

diff --git a/ios/chrome/browser/ui/payments/payment_request_manager.mm b/ios/chrome/browser/ui/payments/payment_request_manager.mm
index 723990d9..54fd157 100644
--- a/ios/chrome/browser/ui/payments/payment_request_manager.mm
+++ b/ios/chrome/browser/ui/payments/payment_request_manager.mm
@@ -720,18 +720,26 @@
 
 #pragma mark - PaymentRequestUIDelegate
 
+- (void)paymentRequestDidFetchPaymentMethods:
+    (payments::PaymentRequest*)paymentRequest {
+  [_paymentRequestCoordinator setPending:NO];
+  [_paymentRequestCoordinator setCancellable:YES];
+}
+
 - (void)
+       paymentRequest:(payments::PaymentRequest*)paymentRequest
 requestFullCreditCard:(const autofill::CreditCard&)creditCard
        resultDelegate:
            (base::WeakPtr<autofill::payments::FullCardRequest::ResultDelegate>)
-               resultDelegate {
+               delegate {
   [_paymentRequestCoordinator requestFullCreditCard:creditCard
-                                     resultDelegate:resultDelegate];
+                                     resultDelegate:delegate];
 }
 
-- (void)launchAppWithUniversalLink:(std::string)universalLink
-                instrumentDelegate:
-                    (payments::PaymentInstrument::Delegate*)instrumentDelegate {
+- (void)paymentInstrument:(payments::IOSPaymentInstrument*)paymentInstrument
+    launchAppWithUniversalLink:(std::string)universalLink
+            instrumentDelegate:
+                (payments::PaymentInstrument::Delegate*)delegate {
   // TODO(crbug.com/748556): Implement this function to use a native app's
   // universal link to open it from Chrome with several arguments supplied
   // from the Payment Request object.
@@ -809,6 +817,7 @@
 
 - (void)paymentResponseHelperDidReceivePaymentMethodDetails {
   [_paymentRequestCoordinator setPending:YES];
+  [_paymentRequestCoordinator setCancellable:NO];
 }
 
 - (void)paymentResponseHelperDidCompleteWithPaymentResponse:

ios/chrome/browser/ui/payments/payment_request_mediator.mm

diff --git a/ios/chrome/browser/ui/payments/payment_request_mediator.mm b/ios/chrome/browser/ui/payments/payment_request_mediator.mm
index f760154..c4dbfb6 100644
--- a/ios/chrome/browser/ui/payments/payment_request_mediator.mm
+++ b/ios/chrome/browser/ui/payments/payment_request_mediator.mm
@@ -18,6 +18,7 @@
 #include "components/payments/core/strings_util.h"
 #include "components/prefs/pref_service.h"
 #include "components/strings/grit/components_strings.h"
+#include "ios/chrome/browser/payments/ios_payment_instrument.h"
 #include "ios/chrome/browser/payments/payment_request.h"
 #include "ios/chrome/browser/payments/payment_request_util.h"
 #import "ios/chrome/browser/ui/collection_view/cells/collection_view_detail_item.h"
@@ -185,13 +186,24 @@
 }
 
 - (CollectionViewItem*)paymentMethodItem {
-  const payments::PaymentInstrument* paymentMethod =
+  payments::PaymentInstrument* paymentMethod =
       self.paymentRequest->selected_payment_method();
   if (paymentMethod) {
     PaymentMethodItem* item = [[PaymentMethodItem alloc] init];
     item.methodID = base::SysUTF16ToNSString(paymentMethod->GetLabel());
     item.methodDetail = base::SysUTF16ToNSString(paymentMethod->GetSublabel());
-    item.methodTypeIcon = NativeImage(paymentMethod->icon_resource_id());
+
+    switch (paymentMethod->type()) {
+      case payments::PaymentInstrument::Type::AUTOFILL:
+        item.methodTypeIcon = NativeImage(paymentMethod->icon_resource_id());
+        break;
+      case payments::PaymentInstrument::Type::NATIVE_MOBILE_APP:
+        payments::IOSPaymentInstrument* mobileApp =
+            static_cast<payments::IOSPaymentInstrument*>(paymentMethod);
+        item.methodTypeIcon = mobileApp->icon_image();
+        break;
+    }
+
     item.accessoryType = MDCCollectionViewCellAccessoryDisclosureIndicator;
     return item;
   }

ios/chrome/browser/ui/payments/payment_request_view_controller.h

diff --git a/ios/chrome/browser/ui/payments/payment_request_view_controller.h b/ios/chrome/browser/ui/payments/payment_request_view_controller.h
index 4de391d..56ff6b3 100644
--- a/ios/chrome/browser/ui/payments/payment_request_view_controller.h
+++ b/ios/chrome/browser/ui/payments/payment_request_view_controller.h
@@ -71,6 +71,9 @@
 // Whether or not the view is in a pending state.
 @property(nonatomic, assign, getter=isPending) BOOL pending;
 
+// Whether or not the user can cancel out of the view.
+@property(nonatomic, assign, getter=isCancellable) BOOL cancellable;
+
 // The delegate to be notified when the user confirms or cancels the request.
 @property(nonatomic, weak) id<PaymentRequestViewControllerDelegate> delegate;
 

ios/chrome/browser/ui/payments/payment_request_view_controller.mm

diff --git a/ios/chrome/browser/ui/payments/payment_request_view_controller.mm b/ios/chrome/browser/ui/payments/payment_request_view_controller.mm
index 8b85084..baedd72 100644
--- a/ios/chrome/browser/ui/payments/payment_request_view_controller.mm
+++ b/ios/chrome/browser/ui/payments/payment_request_view_controller.mm
@@ -78,6 +78,7 @@
 @synthesize pageHost = _pageHost;
 @synthesize connectionSecure = _connectionSecure;
 @synthesize pending = _pending;
+@synthesize cancellable = _cancellable;
 @synthesize delegate = _delegate;
 @synthesize dataSource = _dataSource;
 
@@ -153,6 +154,12 @@
   [_payButton setEnabled:[_dataSource canPay]];
 }
 
+- (void)setCancellable:(BOOL)cancellable {
+  _cancellable = cancellable;
+  [_cancelButton setEnabled:_cancellable];
+  self.view.userInteractionEnabled = cancellable;
+}
+
 #pragma mark - CollectionViewController methods
 
 - (void)loadModel {
@@ -172,7 +179,6 @@
 
   if (_pending) {
     [_payButton setEnabled:NO];
-    [_cancelButton setEnabled:NO];
 
     StatusItem* statusItem = [[StatusItem alloc] initWithType:ItemTypeSpinner];
     statusItem.text = l10n_util::GetNSString(IDS_PAYMENTS_PROCESSING_MESSAGE);

ios/chrome/browser/ui/toolbar/toolbar_model_impl_ios_unittest.mm

diff --git a/ios/chrome/browser/ui/toolbar/toolbar_model_impl_ios_unittest.mm b/ios/chrome/browser/ui/toolbar/toolbar_model_impl_ios_unittest.mm
index 4c77e57..5466a3c 100644
--- a/ios/chrome/browser/ui/toolbar/toolbar_model_impl_ios_unittest.mm
+++ b/ios/chrome/browser/ui/toolbar/toolbar_model_impl_ios_unittest.mm
@@ -20,6 +20,7 @@
 #include "ios/chrome/browser/ui/toolbar/toolbar_model_impl_ios.h"
 #include "ios/chrome/browser/web_state_list/fake_web_state_list_delegate.h"
 #include "ios/chrome/browser/web_state_list/web_state_list.h"
+#import "ios/chrome/browser/web_state_list/web_state_opener.h"
 #import "ios/testing/ocmock_complex_type_helper.h"
 #import "ios/web/public/test/fakes/test_navigation_manager.h"
 #import "ios/web/public/test/fakes/test_web_state.h"
@@ -57,8 +58,10 @@
         base::MakeUnique<ToolbarTestWebState>();
     web_state->SetBrowserState(chrome_browser_state_.get());
     web_state_ = web_state.get();
-    web_state_list_->InsertWebState(0, std::move(web_state));
-    web_state_list_->ActivateWebStateAt(0);
+    web_state_list_->InsertWebState(
+        0, std::move(web_state),
+        WebStateList::INSERT_FORCE_INDEX | WebStateList::INSERT_ACTIVATE,
+        WebStateOpener());
 
     toolbarModelDelegate_.reset(
         new ToolbarModelDelegateIOS(web_state_list_.get()));

ios/chrome/browser/web_state_list/BUILD.gn

diff --git a/ios/chrome/browser/web_state_list/BUILD.gn b/ios/chrome/browser/web_state_list/BUILD.gn
index 3b8eb0e..c8836439 100644
--- a/ios/chrome/browser/web_state_list/BUILD.gn
+++ b/ios/chrome/browser/web_state_list/BUILD.gn
@@ -26,7 +26,6 @@
     "//base",
     "//ios/chrome/browser/sessions:serialisation",
     "//ios/web",
-    "//ui/base",
   ]
   libs = [ "Foundation.framework" ]
   configs += [ "//build/config/compiler:enable_arc" ]
@@ -63,7 +62,6 @@
     "//ios/web/public/test/fakes",
     "//net",
     "//testing/gtest",
-    "//ui/base",
     "//url",
   ]
   configs += [ "//build/config/compiler:enable_arc" ]

ios/chrome/browser/web_state_list/web_state_list.h

diff --git a/ios/chrome/browser/web_state_list/web_state_list.h b/ios/chrome/browser/web_state_list/web_state_list.h
index f87064d8..da524e1 100644
--- a/ios/chrome/browser/web_state_list/web_state_list.h
+++ b/ios/chrome/browser/web_state_list/web_state_list.h
@@ -11,7 +11,6 @@
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
-#include "ui/base/page_transition_types.h"
 
 class WebStateListDelegate;
 class WebStateListObserver;
@@ -25,6 +24,26 @@
 // Manages a list of WebStates.
 class WebStateList {
  public:
+  // Constants used when inserting WebStates.
+  enum InsertionFlags {
+    // Used to indicate that nothing special should happen to the newly
+    // inserted WebState.
+    INSERT_NO_FLAGS = 0,
+
+    // Used to indicate that the WebState should be activated on insertion.
+    INSERT_ACTIVATE = 1 << 0,
+
+    // If not set, the insertion index of the WebState is left up to the
+    // order controller associated with the WebStateList so the insertion
+    // index may differ from the specified index. Otherwise the supplied
+    // index is used.
+    INSERT_FORCE_INDEX = 1 << 1,
+
+    // If set, the WebState opener is set to the active WebState, otherwise
+    // it must be explicitly passed.
+    INSERT_INHERIT_OPENER = 1 << 2,
+  };
+
   explicit WebStateList(WebStateListDelegate* delegate);
   ~WebStateList();
 
@@ -77,15 +96,14 @@
                                      int start_index,
                                      bool use_group) const;
 
-  // Inserts the specified WebState at the specified index.
-  void InsertWebState(int index, std::unique_ptr<web::WebState> web_state);
-
   // Inserts the specified WebState at the best position in the WebStateList
-  // given the specified transition, opener, etc. It defaults to inserting the
-  // WebState at the end of the list.
-  void AppendWebState(ui::PageTransition transition,
-                      std::unique_ptr<web::WebState> web_state,
-                      WebStateOpener opener);
+  // given the specified opener, recommended index, insertion flags, ... The
+  // |insertion_flags| is a bitwise combination of InsertionFlags  values.
+  // Returns the effective insertion index.
+  int InsertWebState(int index,
+                     std::unique_ptr<web::WebState> web_state,
+                     int insertion_flags,
+                     WebStateOpener opener);
 
   // Moves the WebState at the specified index to another index.
   void MoveWebStateAt(int from_index, int to_index);

ios/chrome/browser/web_state_list/web_state_list.mm

diff --git a/ios/chrome/browser/web_state_list/web_state_list.mm b/ios/chrome/browser/web_state_list/web_state_list.mm
index e98729e7..c0fa81a4 100644
--- a/ios/chrome/browser/web_state_list/web_state_list.mm
+++ b/ios/chrome/browser/web_state_list/web_state_list.mm
@@ -20,6 +20,15 @@
 #error "This file requires ARC support."
 #endif
 
+namespace {
+
+// Returns whether the given flag is set in a flagset.
+bool IsInsertionFlagSet(int flagset, WebStateList::InsertionFlags flag) {
+  return (flagset & flag) == flag;
+}
+
+}  // namespace
+
 // Wrapper around a WebState stored in a WebStateList.
 class WebStateList::WebStateWrapper {
  public:
@@ -64,7 +73,7 @@
     std::unique_ptr<web::WebState> web_state) {
   DCHECK_NE(web_state.get(), web_state_.get());
   std::swap(web_state, web_state_);
-  opener_ = WebStateOpener(nullptr);
+  opener_ = WebStateOpener();
   return web_state;
 }
 
@@ -137,8 +146,19 @@
   return GetIndexOfNthWebStateOpenedBy(opener, start_index, use_group, INT_MAX);
 }
 
-void WebStateList::InsertWebState(int index,
-                                  std::unique_ptr<web::WebState> web_state) {
+int WebStateList::InsertWebState(int index,
+                                 std::unique_ptr<web::WebState> web_state,
+                                 int insertion_flags,
+                                 WebStateOpener opener) {
+  if (IsInsertionFlagSet(insertion_flags, INSERT_INHERIT_OPENER))
+    opener = WebStateOpener(GetActiveWebState());
+
+  if (!IsInsertionFlagSet(insertion_flags, INSERT_FORCE_INDEX)) {
+    index = order_controller_->DetermineInsertionIndex(opener.opener);
+    if (index < 0 || count() < index)
+      index = count();
+  }
+
   DCHECK(ContainsIndex(index) || index == count());
   delegate_->WillAddWebState(web_state.get());
 
@@ -150,22 +170,17 @@
   if (active_index_ >= index)
     ++active_index_;
 
+  const bool activating = IsInsertionFlagSet(insertion_flags, INSERT_ACTIVATE);
   for (auto& observer : observers_)
     observer.WebStateInsertedAt(this, web_state_ptr, index);
-}
-
-void WebStateList::AppendWebState(ui::PageTransition transition,
-                                  std::unique_ptr<web::WebState> web_state,
-                                  WebStateOpener opener) {
-  int index =
-      order_controller_->DetermineInsertionIndex(transition, opener.opener);
-  if (index < 0 || count() < index)
-    index = count();
-
-  InsertWebState(index, std::move(web_state));
 
   if (opener.opener)
     SetOpenerOfWebStateAt(index, opener);
+
+  if (activating)
+    ActivateWebStateAt(index);
+
+  return index;
 }
 
 void WebStateList::MoveWebStateAt(int from_index, int to_index) {
@@ -280,7 +295,7 @@
   web::WebState* old_web_state = web_state_wrappers_[index]->web_state();
   for (auto& web_state_wrapper : web_state_wrappers_) {
     if (web_state_wrapper->opener().opener == old_web_state)
-      web_state_wrapper->set_opener(WebStateOpener(nullptr));
+      web_state_wrapper->set_opener(WebStateOpener());
   }
 }
 

ios/chrome/browser/web_state_list/web_state_list_fast_enumeration_helper_unittest.mm

diff --git a/ios/chrome/browser/web_state_list/web_state_list_fast_enumeration_helper_unittest.mm b/ios/chrome/browser/web_state_list/web_state_list_fast_enumeration_helper_unittest.mm
index 6465c101..5e0c7a2 100644
--- a/ios/chrome/browser/web_state_list/web_state_list_fast_enumeration_helper_unittest.mm
+++ b/ios/chrome/browser/web_state_list/web_state_list_fast_enumeration_helper_unittest.mm
@@ -8,6 +8,7 @@
 #include "base/memory/ptr_util.h"
 #import "ios/chrome/browser/web_state_list/fake_web_state_list_delegate.h"
 #import "ios/chrome/browser/web_state_list/web_state_list.h"
+#import "ios/chrome/browser/web_state_list/web_state_opener.h"
 #import "ios/web/public/test/fakes/test_web_state.h"
 #import "net/base/mac/url_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -64,8 +65,9 @@
       auto test_web_state = base::MakeUnique<web::TestWebState>();
       test_web_state->SetCurrentURL(GURL(urls[index]));
 
-      web_state_list_.InsertWebState(web_state_list_.count(),
-                                     std::move(test_web_state));
+      web_state_list_.InsertWebState(
+          web_state_list_.count(), std::move(test_web_state),
+          WebStateList::INSERT_FORCE_INDEX, WebStateOpener());
     }
   }
 

ios/chrome/browser/web_state_list/web_state_list_order_controller.h

diff --git a/ios/chrome/browser/web_state_list/web_state_list_order_controller.h b/ios/chrome/browser/web_state_list/web_state_list_order_controller.h
index 0491002d..ad25a6b 100644
--- a/ios/chrome/browser/web_state_list/web_state_list_order_controller.h
+++ b/ios/chrome/browser/web_state_list/web_state_list_order_controller.h
@@ -6,7 +6,6 @@
 #define IOS_CHROME_BROWSER_WEB_STATE_LIST_WEB_STATE_LIST_ORDER_CONTROLLER_H_
 
 #include "base/macros.h"
-#include "ui/base/page_transition_types.h"
 
 class WebStateList;
 
@@ -21,10 +20,8 @@
   explicit WebStateListOrderController(WebStateList* web_state_list);
   ~WebStateListOrderController();
 
-  // Determines where to place a newly opened WebState by using the supplied
-  // transition, opener and background flag.
-  int DetermineInsertionIndex(ui::PageTransition transition,
-                              web::WebState* opener) const;
+  // Determines where to place a newly opened WebState given its opener.
+  int DetermineInsertionIndex(web::WebState* opener) const;
 
   // Determines where to shift the active index after a WebState is closed.
   int DetermineNewActiveIndex(int removing_index) const;

ios/chrome/browser/web_state_list/web_state_list_order_controller.mm

diff --git a/ios/chrome/browser/web_state_list/web_state_list_order_controller.mm b/ios/chrome/browser/web_state_list/web_state_list_order_controller.mm
index 38d6b5c..46579b8 100644
--- a/ios/chrome/browser/web_state_list/web_state_list_order_controller.mm
+++ b/ios/chrome/browser/web_state_list/web_state_list_order_controller.mm
@@ -19,14 +19,10 @@
 WebStateListOrderController::~WebStateListOrderController() = default;
 
 int WebStateListOrderController::DetermineInsertionIndex(
-    ui::PageTransition transition,
     web::WebState* opener) const {
   if (!opener)
     return web_state_list_->count();
 
-  if (!PageTransitionCoreTypeIs(transition, ui::PAGE_TRANSITION_LINK))
-    return web_state_list_->count();
-
   int opener_index = web_state_list_->GetIndexOfWebState(opener);
   DCHECK_NE(WebStateList::kInvalidIndex, opener_index);
 
@@ -54,19 +50,19 @@
   if (index != WebStateList::kInvalidIndex)
     return GetValidIndex(index, removing_index);
 
-  WebStateOpener opener =
-      web_state_list_->GetOpenerOfWebStateAt(removing_index);
-  if (opener.opener) {
+  web::WebState* opener =
+      web_state_list_->GetOpenerOfWebStateAt(removing_index).opener;
+  if (opener) {
     // If the WebState was in a group, shift selection to the next WebState in
     // the group.
     int index = web_state_list_->GetIndexOfNextWebStateOpenedBy(
-        opener.opener, removing_index, false);
+        opener, removing_index, false);
 
     if (index != WebStateList::kInvalidIndex)
       return GetValidIndex(index, removing_index);
 
     // If there is no subsequent group member, just fall back to opener itself.
-    index = web_state_list_->GetIndexOfWebState(opener.opener);
+    index = web_state_list_->GetIndexOfWebState(opener);
     return GetValidIndex(index, removing_index);
   }
 

ios/chrome/browser/web_state_list/web_state_list_order_controller_unittest.mm

diff --git a/ios/chrome/browser/web_state_list/web_state_list_order_controller_unittest.mm b/ios/chrome/browser/web_state_list/web_state_list_order_controller_unittest.mm
index ad18521..89b3c7f 100644
--- a/ios/chrome/browser/web_state_list/web_state_list_order_controller_unittest.mm
+++ b/ios/chrome/browser/web_state_list/web_state_list_order_controller_unittest.mm
@@ -15,7 +15,6 @@
 #import "ios/web/public/test/fakes/test_web_state.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
-#include "ui/base/page_transition_types.h"
 
 namespace {
 const char kURL[] = "https://chromium.org/";
@@ -45,13 +44,13 @@
   WebStateList web_state_list_;
   WebStateListOrderController order_controller_;
 
-  std::unique_ptr<web::WebState> CreateWebState() {
+  void InsertNewWebState(int index, WebStateOpener opener) {
     auto test_web_state = base::MakeUnique<web::TestWebState>();
     test_web_state->SetCurrentURL(GURL(kURL));
     test_web_state->SetNavigationManager(
         base::MakeUnique<FakeNavigationManager>());
-    // TODO(crbug.com/703565): remove std::move() once Xcode 9.0+ is required.
-    return std::move(test_web_state);
+    web_state_list_.InsertWebState(index, std::move(test_web_state),
+                                   WebStateList::INSERT_FORCE_INDEX, opener);
   }
 
  private:
@@ -59,38 +58,26 @@
 };
 
 TEST_F(WebStateListOrderControllerTest, DetermineInsertionIndex) {
-  web_state_list_.InsertWebState(0, CreateWebState());
-  web_state_list_.InsertWebState(1, CreateWebState());
+  InsertNewWebState(0, WebStateOpener());
+  InsertNewWebState(1, WebStateOpener());
   web::WebState* opener = web_state_list_.GetWebStateAt(0);
 
   // Verify that first child WebState is inserted after |opener| if there are
   // no other children.
-  EXPECT_EQ(1, order_controller_.DetermineInsertionIndex(
-                   ui::PAGE_TRANSITION_LINK, opener));
-
-  // Verify that child WebState is inserted at the end if it is not a "LINK"
-  // transition.
-  EXPECT_EQ(2, order_controller_.DetermineInsertionIndex(
-                   ui::PAGE_TRANSITION_GENERATED, opener));
+  EXPECT_EQ(1, order_controller_.DetermineInsertionIndex(opener));
 
   // Verify that  WebState is inserted at the end if it has no opener.
-  EXPECT_EQ(2, order_controller_.DetermineInsertionIndex(
-                   ui::PAGE_TRANSITION_LINK, nullptr));
+  EXPECT_EQ(2, order_controller_.DetermineInsertionIndex(nullptr));
 
   // Add a child WebState to |opener|, and verify that a second child would be
   // inserted after the first.
-  web_state_list_.InsertWebState(2, CreateWebState());
-  web_state_list_.SetOpenerOfWebStateAt(2, WebStateOpener(opener));
+  InsertNewWebState(2, WebStateOpener(opener));
 
-  EXPECT_EQ(3, order_controller_.DetermineInsertionIndex(
-                   ui::PAGE_TRANSITION_LINK, opener));
+  EXPECT_EQ(3, order_controller_.DetermineInsertionIndex(opener));
 
   // Add a grand-child to |opener|, and verify that adding another child to
   // |opener| would be inserted before the grand-child.
-  web_state_list_.InsertWebState(3, CreateWebState());
-  web_state_list_.SetOpenerOfWebStateAt(
-      3, WebStateOpener(web_state_list_.GetWebStateAt(1)));
+  InsertNewWebState(3, WebStateOpener(web_state_list_.GetWebStateAt(1)));
 
-  EXPECT_EQ(3, order_controller_.DetermineInsertionIndex(
-                   ui::PAGE_TRANSITION_LINK, opener));
+  EXPECT_EQ(3, order_controller_.DetermineInsertionIndex(opener));
 }

ios/chrome/browser/web_state_list/web_state_list_serialization.mm

diff --git a/ios/chrome/browser/web_state_list/web_state_list_serialization.mm b/ios/chrome/browser/web_state_list/web_state_list_serialization.mm
index f104d3a5..9609bbb 100644
--- a/ios/chrome/browser/web_state_list/web_state_list_serialization.mm
+++ b/ios/chrome/browser/web_state_list/web_state_list_serialization.mm
@@ -175,8 +175,9 @@
   int old_count = web_state_list->count();
   for (CRWSessionStorage* session in session_window.sessions) {
     std::unique_ptr<web::WebState> web_state = web_state_factory.Run(session);
-    web_state_list->InsertWebState(web_state_list->count(),
-                                   std::move(web_state));
+    web_state_list->InsertWebState(
+        web_state_list->count(), std::move(web_state),
+        WebStateList::INSERT_FORCE_INDEX, WebStateOpener());
   }
 
   RestoreRelationship(web_state_list, old_count);

ios/chrome/browser/web_state_list/web_state_list_serialization_unittest.mm

diff --git a/ios/chrome/browser/web_state_list/web_state_list_serialization_unittest.mm b/ios/chrome/browser/web_state_list/web_state_list_serialization_unittest.mm
index b4af185d..a59e0a9 100644
--- a/ios/chrome/browser/web_state_list/web_state_list_serialization_unittest.mm
+++ b/ios/chrome/browser/web_state_list/web_state_list_serialization_unittest.mm
@@ -106,17 +106,19 @@
 
 TEST_F(WebStateListSerializationTest, SerializationRoundTrip) {
   WebStateList original_web_state_list(web_state_list_delegate());
-  original_web_state_list.InsertWebState(0, SerializableTestWebState::Create());
-  original_web_state_list.InsertWebState(1, SerializableTestWebState::Create());
-  original_web_state_list.InsertWebState(2, SerializableTestWebState::Create());
-  original_web_state_list.InsertWebState(3, SerializableTestWebState::Create());
-  original_web_state_list.SetOpenerOfWebStateAt(
-      1, WebStateOpener(original_web_state_list.GetWebStateAt(0), 3));
-  original_web_state_list.SetOpenerOfWebStateAt(
-      2, WebStateOpener(original_web_state_list.GetWebStateAt(0), 2));
-  original_web_state_list.SetOpenerOfWebStateAt(
-      3, WebStateOpener(original_web_state_list.GetWebStateAt(1), 1));
-  original_web_state_list.ActivateWebStateAt(1);
+  original_web_state_list.InsertWebState(0, SerializableTestWebState::Create(),
+                                         WebStateList::INSERT_FORCE_INDEX,
+                                         WebStateOpener());
+  original_web_state_list.InsertWebState(
+      1, SerializableTestWebState::Create(),
+      WebStateList::INSERT_FORCE_INDEX | WebStateList::INSERT_ACTIVATE,
+      WebStateOpener(original_web_state_list.GetWebStateAt(0), 3));
+  original_web_state_list.InsertWebState(
+      2, SerializableTestWebState::Create(), WebStateList::INSERT_FORCE_INDEX,
+      WebStateOpener(original_web_state_list.GetWebStateAt(0), 2));
+  original_web_state_list.InsertWebState(
+      3, SerializableTestWebState::Create(), WebStateList::INSERT_FORCE_INDEX,
+      WebStateOpener(original_web_state_list.GetWebStateAt(1), 1));
 
   SessionWindowIOS* session_window =
       SerializeWebStateList(&original_web_state_list);
@@ -126,7 +128,9 @@
 
   // Create a deserialized WebStateList and verify its contents.
   WebStateList restored_web_state_list(web_state_list_delegate());
-  restored_web_state_list.InsertWebState(0, SerializableTestWebState::Create());
+  restored_web_state_list.InsertWebState(0, SerializableTestWebState::Create(),
+                                         WebStateList::INSERT_FORCE_INDEX,
+                                         WebStateOpener());
   ASSERT_EQ(1, restored_web_state_list.count());
 
   DeserializeWebStateList(

ios/chrome/browser/web_state_list/web_state_list_unittest.mm

diff --git a/ios/chrome/browser/web_state_list/web_state_list_unittest.mm b/ios/chrome/browser/web_state_list/web_state_list_unittest.mm
index 5bbade1b..ca205b9 100644
--- a/ios/chrome/browser/web_state_list/web_state_list_unittest.mm
+++ b/ios/chrome/browser/web_state_list/web_state_list_unittest.mm
@@ -135,13 +135,22 @@
   WebStateList web_state_list_;
   WebStateListTestObserver observer_;
 
-  std::unique_ptr<web::WebState> CreateWebState(const char* url) {
+  std::unique_ptr<web::TestWebState> CreateWebState(const char* url) {
     auto test_web_state = base::MakeUnique<web::TestWebState>();
     test_web_state->SetCurrentURL(GURL(url));
     test_web_state->SetNavigationManager(
         base::MakeUnique<FakeNavigationManager>());
-    // TODO(crbug.com/703565): remove std::move() once Xcode 9.0+ is required.
-    return std::move(test_web_state);
+    return test_web_state;
+  }
+
+  void AppendNewWebState(const char* url) {
+    AppendNewWebState(url, WebStateOpener());
+  }
+
+  void AppendNewWebState(const char* url, WebStateOpener opener) {
+    web_state_list_.InsertWebState(WebStateList::kInvalidIndex,
+                                   CreateWebState(url),
+                                   WebStateList::INSERT_NO_FLAGS, opener);
   }
 
  private:
@@ -152,7 +161,7 @@
   EXPECT_EQ(0, web_state_list_.count());
   EXPECT_TRUE(web_state_list_.empty());
 
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
+  AppendNewWebState(kURL0);
 
   EXPECT_TRUE(observer_.web_state_inserted_called());
   EXPECT_EQ(1, web_state_list_.count());
@@ -160,29 +169,73 @@
 }
 
 TEST_F(WebStateListTest, InsertUrlSingle) {
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
+  AppendNewWebState(kURL0);
 
   EXPECT_TRUE(observer_.web_state_inserted_called());
-  EXPECT_EQ(1, web_state_list_.count());
+  ASSERT_EQ(1, web_state_list_.count());
   EXPECT_EQ(kURL0, web_state_list_.GetWebStateAt(0)->GetVisibleURL().spec());
 }
 
 TEST_F(WebStateListTest, InsertUrlMultiple) {
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
-  web_state_list_.InsertWebState(0, CreateWebState(kURL1));
-  web_state_list_.InsertWebState(1, CreateWebState(kURL2));
+  web_state_list_.InsertWebState(0, CreateWebState(kURL0),
+                                 WebStateList::INSERT_FORCE_INDEX,
+                                 WebStateOpener());
+  web_state_list_.InsertWebState(0, CreateWebState(kURL1),
+                                 WebStateList::INSERT_FORCE_INDEX,
+                                 WebStateOpener());
+  web_state_list_.InsertWebState(1, CreateWebState(kURL2),
+                                 WebStateList::INSERT_FORCE_INDEX,
+                                 WebStateOpener());
 
   EXPECT_TRUE(observer_.web_state_inserted_called());
-  EXPECT_EQ(3, web_state_list_.count());
+  ASSERT_EQ(3, web_state_list_.count());
   EXPECT_EQ(kURL1, web_state_list_.GetWebStateAt(0)->GetVisibleURL().spec());
   EXPECT_EQ(kURL2, web_state_list_.GetWebStateAt(1)->GetVisibleURL().spec());
   EXPECT_EQ(kURL0, web_state_list_.GetWebStateAt(2)->GetVisibleURL().spec());
 }
 
+TEST_F(WebStateListTest, ActivateWebState) {
+  AppendNewWebState(kURL0);
+  EXPECT_EQ(nullptr, web_state_list_.GetActiveWebState());
+
+  web_state_list_.ActivateWebStateAt(0);
+
+  ASSERT_EQ(1, web_state_list_.count());
+  EXPECT_EQ(web_state_list_.GetWebStateAt(0),
+            web_state_list_.GetActiveWebState());
+}
+
+TEST_F(WebStateListTest, InsertActivate) {
+  web_state_list_.InsertWebState(
+      0, CreateWebState(kURL0),
+      WebStateList::INSERT_FORCE_INDEX | WebStateList::INSERT_ACTIVATE,
+      WebStateOpener());
+
+  ASSERT_EQ(1, web_state_list_.count());
+  EXPECT_EQ(web_state_list_.GetWebStateAt(0),
+            web_state_list_.GetActiveWebState());
+}
+
+TEST_F(WebStateListTest, InsertInheritOpener) {
+  AppendNewWebState(kURL0);
+  web_state_list_.ActivateWebStateAt(0);
+  ASSERT_EQ(1, web_state_list_.count());
+  ASSERT_EQ(web_state_list_.GetWebStateAt(0),
+            web_state_list_.GetActiveWebState());
+
+  web_state_list_.InsertWebState(
+      WebStateList::kInvalidIndex, CreateWebState(kURL1),
+      WebStateList::INSERT_INHERIT_OPENER, WebStateOpener());
+
+  ASSERT_EQ(2, web_state_list_.count());
+  ASSERT_EQ(web_state_list_.GetActiveWebState(),
+            web_state_list_.GetOpenerOfWebStateAt(1).opener);
+}
+
 TEST_F(WebStateListTest, MoveWebStateAtRightByOne) {
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
-  web_state_list_.InsertWebState(1, CreateWebState(kURL1));
-  web_state_list_.InsertWebState(2, CreateWebState(kURL2));
+  AppendNewWebState(kURL0);
+  AppendNewWebState(kURL1);
+  AppendNewWebState(kURL2);
 
   // Sanity check before closing WebState.
   EXPECT_EQ(3, web_state_list_.count());
@@ -201,9 +254,9 @@
 }
 
 TEST_F(WebStateListTest, MoveWebStateAtRightByMoreThanOne) {
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
-  web_state_list_.InsertWebState(1, CreateWebState(kURL1));
-  web_state_list_.InsertWebState(2, CreateWebState(kURL2));
+  AppendNewWebState(kURL0);
+  AppendNewWebState(kURL1);
+  AppendNewWebState(kURL2);
 
   // Sanity check before closing WebState.
   EXPECT_EQ(3, web_state_list_.count());
@@ -222,9 +275,9 @@
 }
 
 TEST_F(WebStateListTest, MoveWebStateAtLeftByOne) {
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
-  web_state_list_.InsertWebState(1, CreateWebState(kURL1));
-  web_state_list_.InsertWebState(2, CreateWebState(kURL2));
+  AppendNewWebState(kURL0);
+  AppendNewWebState(kURL1);
+  AppendNewWebState(kURL2);
 
   // Sanity check before closing WebState.
   EXPECT_EQ(3, web_state_list_.count());
@@ -243,9 +296,9 @@
 }
 
 TEST_F(WebStateListTest, MoveWebStateAtLeftByMoreThanOne) {
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
-  web_state_list_.InsertWebState(1, CreateWebState(kURL1));
-  web_state_list_.InsertWebState(2, CreateWebState(kURL2));
+  AppendNewWebState(kURL0);
+  AppendNewWebState(kURL1);
+  AppendNewWebState(kURL2);
 
   // Sanity check before closing WebState.
   EXPECT_EQ(3, web_state_list_.count());
@@ -264,9 +317,9 @@
 }
 
 TEST_F(WebStateListTest, MoveWebStateAtSameIndex) {
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
-  web_state_list_.InsertWebState(1, CreateWebState(kURL1));
-  web_state_list_.InsertWebState(2, CreateWebState(kURL2));
+  AppendNewWebState(kURL0);
+  AppendNewWebState(kURL1);
+  AppendNewWebState(kURL2);
 
   // Sanity check before closing WebState.
   EXPECT_EQ(3, web_state_list_.count());
@@ -285,8 +338,8 @@
 }
 
 TEST_F(WebStateListTest, ReplaceWebStateAt) {
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
-  web_state_list_.InsertWebState(1, CreateWebState(kURL1));
+  AppendNewWebState(kURL0);
+  AppendNewWebState(kURL1);
 
   // Sanity check before replacing WebState.
   EXPECT_EQ(2, web_state_list_.count());
@@ -305,9 +358,9 @@
 }
 
 TEST_F(WebStateListTest, DetachWebStateAtIndexBegining) {
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
-  web_state_list_.InsertWebState(1, CreateWebState(kURL1));
-  web_state_list_.InsertWebState(2, CreateWebState(kURL2));
+  AppendNewWebState(kURL0);
+  AppendNewWebState(kURL1);
+  AppendNewWebState(kURL2);
 
   // Sanity check before closing WebState.
   EXPECT_EQ(3, web_state_list_.count());
@@ -325,9 +378,9 @@
 }
 
 TEST_F(WebStateListTest, DetachWebStateAtIndexMiddle) {
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
-  web_state_list_.InsertWebState(1, CreateWebState(kURL1));
-  web_state_list_.InsertWebState(2, CreateWebState(kURL2));
+  AppendNewWebState(kURL0);
+  AppendNewWebState(kURL1);
+  AppendNewWebState(kURL2);
 
   // Sanity check before closing WebState.
   EXPECT_EQ(3, web_state_list_.count());
@@ -345,9 +398,9 @@
 }
 
 TEST_F(WebStateListTest, DetachWebStateAtIndexLast) {
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
-  web_state_list_.InsertWebState(1, CreateWebState(kURL1));
-  web_state_list_.InsertWebState(2, CreateWebState(kURL2));
+  AppendNewWebState(kURL0);
+  AppendNewWebState(kURL1);
+  AppendNewWebState(kURL2);
 
   // Sanity check before closing WebState.
   EXPECT_EQ(3, web_state_list_.count());
@@ -383,9 +436,9 @@
 }
 
 TEST_F(WebStateListTest, OpenersNothingOpened) {
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
-  web_state_list_.InsertWebState(1, CreateWebState(kURL1));
-  web_state_list_.InsertWebState(2, CreateWebState(kURL2));
+  AppendNewWebState(kURL0);
+  AppendNewWebState(kURL1);
+  AppendNewWebState(kURL2);
 
   for (int index = 0; index < web_state_list_.count(); ++index) {
     web::WebState* opener = web_state_list_.GetWebStateAt(index);
@@ -406,14 +459,11 @@
 }
 
 TEST_F(WebStateListTest, OpenersChildsAfterOpener) {
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
+  AppendNewWebState(kURL0);
   web::WebState* opener = web_state_list_.GetWebStateAt(0);
 
-  web_state_list_.InsertWebState(1, CreateWebState(kURL1));
-  web_state_list_.SetOpenerOfWebStateAt(1, WebStateOpener(opener));
-
-  web_state_list_.InsertWebState(2, CreateWebState(kURL2));
-  web_state_list_.SetOpenerOfWebStateAt(2, WebStateOpener(opener));
+  AppendNewWebState(kURL1, WebStateOpener(opener));
+  AppendNewWebState(kURL2, WebStateOpener(opener));
 
   const int start_index = web_state_list_.GetIndexOfWebState(opener);
   EXPECT_EQ(1, web_state_list_.GetIndexOfNextWebStateOpenedBy(
@@ -445,8 +495,9 @@
   // Add a new WebState with the same opener. It should be considered the next
   // WebState if groups are considered and the last independently on whether
   // groups are used or not.
-  web_state_list_.InsertWebState(3, CreateWebState(kURL2));
-  web_state_list_.SetOpenerOfWebStateAt(3, WebStateOpener(opener));
+  web_state_list_.InsertWebState(
+      3, CreateWebState(kURL2), WebStateList::INSERT_FORCE_INDEX,
+      WebStateOpener(web_state_list_.GetWebStateAt(0)));
 
   EXPECT_EQ(1, web_state_list_.GetIndexOfNextWebStateOpenedBy(
                    opener, start_index, false));
@@ -460,14 +511,12 @@
 }
 
 TEST_F(WebStateListTest, OpenersChildsBeforeOpener) {
-  web_state_list_.InsertWebState(0, CreateWebState(kURL0));
+  AppendNewWebState(kURL0);
   web::WebState* opener = web_state_list_.GetWebStateAt(0);
 
-  web_state_list_.InsertWebState(0, CreateWebState(kURL1));
-  web_state_list_.SetOpenerOfWebStateAt(0, WebStateOpener(opener));
-
-  web_state_list_.InsertWebState(1, CreateWebState(kURL2));
-  web_state_list_.SetOpenerOfWebStateAt(1, WebStateOpener(opener));
+  AppendNewWebState(kURL1, WebStateOpener(opener));
+  AppendNewWebState(kURL2, WebStateOpener(opener));
+  web_state_list_.MoveWebStateAt(0, 2);
 
   const int start_index = web_state_list_.GetIndexOfWebState(opener);
   EXPECT_EQ(WebStateList::kInvalidIndex,

ios/chrome/browser/web_state_list/web_state_opener.h

diff --git a/ios/chrome/browser/web_state_list/web_state_opener.h b/ios/chrome/browser/web_state_list/web_state_opener.h
index 9d99e0a..3baac57 100644
--- a/ios/chrome/browser/web_state_list/web_state_opener.h
+++ b/ios/chrome/browser/web_state_list/web_state_opener.h
@@ -19,6 +19,9 @@
   // WebState was open. Value is undefined if |opener| is null.
   int navigation_index;
 
+  // Creates WebStateOpener with a null |opener|.
+  WebStateOpener();
+
   // Creates WebStateOpener initialising the members from |opener| (the
   // |navigation_index| will be initialised from |opener|'s navigation
   // manager if |opener| is not null).
@@ -26,9 +29,6 @@
 
   // Creates WebStateOpener initialising the members from the parameters.
   WebStateOpener(web::WebState* opener, int navigation_index);
-
-  // Forbids default construction.
-  WebStateOpener() = delete;
 };
 
 #endif  // IOS_CHROME_BROWSER_WEB_STATE_LIST_WEB_STATE_OPENER_H_

ios/chrome/browser/web_state_list/web_state_opener.mm

diff --git a/ios/chrome/browser/web_state_list/web_state_opener.mm b/ios/chrome/browser/web_state_list/web_state_opener.mm
index a26cca2..5f7abd46 100644
--- a/ios/chrome/browser/web_state_list/web_state_opener.mm
+++ b/ios/chrome/browser/web_state_list/web_state_opener.mm
@@ -22,6 +22,8 @@
 }
 }  // namespace
 
+WebStateOpener::WebStateOpener() : WebStateOpener(nullptr) {}
+
 WebStateOpener::WebStateOpener(web::WebState* opener)
     : WebStateOpener(opener, NavigationIndexFromWebState(opener)) {}
 

ios/chrome/common/app_group/app_group_metrics.h

diff --git a/ios/chrome/common/app_group/app_group_metrics.h b/ios/chrome/common/app_group/app_group_metrics.h
index 6735588..0c3f589b 100644
--- a/ios/chrome/common/app_group/app_group_metrics.h
+++ b/ios/chrome/common/app_group/app_group_metrics.h
@@ -19,6 +19,14 @@
 // upload.
 extern NSString* const kPendingLogFileDirectory;
 
+// An app_group key to the number of times Search Extension was displayed since
+// last Chrome launch.
+extern NSString* const kSearchExtensionDisplayCount;
+
+// An app_group key to the number of times Content Extension was displayed since
+// last Chrome launch.
+extern NSString* const kContentExtensionDisplayCount;
+
 // Offsets the sessionID to avoid collision. The sessionID is limited to 1<<23.
 int AppGroupSessionID(int sessionID, AppGroupApplications application);
 

ios/chrome/common/app_group/app_group_metrics.mm

diff --git a/ios/chrome/common/app_group/app_group_metrics.mm b/ios/chrome/common/app_group/app_group_metrics.mm
index ab973d9..506b54b4 100644
--- a/ios/chrome/common/app_group/app_group_metrics.mm
+++ b/ios/chrome/common/app_group/app_group_metrics.mm
@@ -16,8 +16,12 @@
 
 NSString* const kPendingLogFileDirectory = @"ExtensionLogs";
 
-// To avoid collision between session_ids from chrome or external components,
-// the session ID is offset depending on the application.
+NSString* const kSearchExtensionDisplayCount = @"SearchExtensionDisplayCount";
+
+NSString* const kContentExtensionDisplayCount = @"ContentExtensionDisplayCount";
+
+// To avoid collision between session_ids from chrome or external
+// components, the session ID is offset depending on the application.
 int AppGroupSessionID(int session_id, AppGroupApplications application) {
   DCHECK_LT(session_id, 1 << 23);
   return (1 << 23) * static_cast<int>(application) + session_id;

ios/chrome/common/app_group/app_group_metrics_mainapp.mm

diff --git a/ios/chrome/common/app_group/app_group_metrics_mainapp.mm b/ios/chrome/common/app_group/app_group_metrics_mainapp.mm
index bfbf7e4..568e88b 100644
--- a/ios/chrome/common/app_group/app_group_metrics_mainapp.mm
+++ b/ios/chrome/common/app_group/app_group_metrics_mainapp.mm
@@ -7,6 +7,7 @@
 #include <stdint.h>
 
 #include "base/logging.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_restrictions.h"
 #include "ios/chrome/common/app_group/app_group_constants.h"
 #include "ios/chrome/common/app_group/app_group_metrics.h"
@@ -20,6 +21,18 @@
 namespace main_app {
 
 void ProcessPendingLogs(ProceduralBlockWithData callback) {
+  NSUserDefaults* shared_defaults = GetGroupUserDefaults();
+  int content_extension_count =
+      [shared_defaults integerForKey:kContentExtensionDisplayCount];
+  UMA_HISTOGRAM_COUNTS_1000("IOS.ContentExtension.DisplayCount",
+                            content_extension_count);
+  [shared_defaults setInteger:0 forKey:kContentExtensionDisplayCount];
+  int search_extension_count =
+      [shared_defaults integerForKey:kSearchExtensionDisplayCount];
+  UMA_HISTOGRAM_COUNTS_1000("IOS.SearchExtension.DisplayCount",
+                            search_extension_count);
+  [shared_defaults setInteger:0 forKey:kSearchExtensionDisplayCount];
+
   base::ThreadRestrictions::AssertIOAllowed();
   NSFileManager* file_manager = [NSFileManager defaultManager];
   NSURL* store_url = [file_manager
@@ -49,8 +62,7 @@
                    NSString* brand_code,
                    int64_t install_date,
                    int64_t enable_metrics_date) {
-  NSUserDefaults* shared_defaults =
-      [[NSUserDefaults alloc] initWithSuiteName:ApplicationGroup()];
+  NSUserDefaults* shared_defaults = GetGroupUserDefaults();
   [shared_defaults setObject:client_id forKey:@(kChromeAppClientID)];
 
   [shared_defaults
@@ -67,6 +79,8 @@
   NSUserDefaults* shared_defaults =
       [[NSUserDefaults alloc] initWithSuiteName:ApplicationGroup()];
   [shared_defaults removeObjectForKey:@(kChromeAppClientID)];
+  [shared_defaults removeObjectForKey:kContentExtensionDisplayCount];
+  [shared_defaults removeObjectForKey:kSearchExtensionDisplayCount];
 }
 
 }  // namespace main_app

ios/chrome/content_widget_extension/content_widget_view_controller.mm

diff --git a/ios/chrome/content_widget_extension/content_widget_view_controller.mm b/ios/chrome/content_widget_extension/content_widget_view_controller.mm
index 8e2557e..088f6e0 100644
--- a/ios/chrome/content_widget_extension/content_widget_view_controller.mm
+++ b/ios/chrome/content_widget_extension/content_widget_view_controller.mm
@@ -12,6 +12,7 @@
 #import "ios/chrome/browser/ui/ntp/ntp_tile.h"
 #import "ios/chrome/browser/ui/util/constraints_ui_util.h"
 #include "ios/chrome/common/app_group/app_group_constants.h"
+#include "ios/chrome/common/app_group/app_group_metrics.h"
 #include "ios/chrome/content_widget_extension/content_widget_view.h"
 #import "ios/chrome/content_widget_extension/most_visited_tile_view.h"
 
@@ -38,6 +39,10 @@
 - (BOOL)updateWidget;
 // Expand the widget.
 - (void)setExpanded:(CGSize)maxSize;
+// Register a display of the widget in the app_group NSUserDefaults.
+// Metrics on the widget usage will be sent (if enabled) on the next Chrome
+// startup.
+- (void)registerWidgetDisplay;
 @end
 
 @implementation ContentWidgetViewController
@@ -85,6 +90,11 @@
   AddSameConstraints(self.widgetView, self.view);
 }
 
+- (void)viewWillAppear:(BOOL)animated {
+  [super viewWillAppear:animated];
+  [self registerWidgetDisplay];
+}
+
 - (void)widgetPerformUpdateWithCompletionHandler:
     (void (^)(NCUpdateResult))completionHandler {
   completionHandler([self updateWidget] ? NCUpdateResultNewData
@@ -149,7 +159,13 @@
   return YES;
 }
 
-#pragma mark - ContentWidgetViewDelegate
+- (void)registerWidgetDisplay {
+  NSUserDefaults* sharedDefaults = app_group::GetGroupUserDefaults();
+  NSInteger numberOfDisplay =
+      [sharedDefaults integerForKey:app_group::kContentExtensionDisplayCount];
+  [sharedDefaults setInteger:numberOfDisplay + 1
+                      forKey:app_group::kContentExtensionDisplayCount];
+}
 
 - (void)openURL:(NSURL*)URL {
   NSUserDefaults* sharedDefaults = app_group::GetGroupUserDefaults();

ios/chrome/search_widget_extension/search_widget_view_controller.mm

diff --git a/ios/chrome/search_widget_extension/search_widget_view_controller.mm b/ios/chrome/search_widget_extension/search_widget_view_controller.mm
index 870c86b..154aaa3 100644
--- a/ios/chrome/search_widget_extension/search_widget_view_controller.mm
+++ b/ios/chrome/search_widget_extension/search_widget_view_controller.mm
@@ -12,6 +12,7 @@
 #include "components/open_from_clipboard/clipboard_recent_content_impl_ios.h"
 #import "ios/chrome/browser/ui/util/constraints_ui_util.h"
 #include "ios/chrome/common/app_group/app_group_constants.h"
+#include "ios/chrome/common/app_group/app_group_metrics.h"
 #import "ios/chrome/search_widget_extension/copied_url_view.h"
 #import "ios/chrome/search_widget_extension/search_widget_view.h"
 
@@ -44,6 +45,10 @@
 // application for a given |command| and |parameter|.
 + (NSDictionary*)dictForCommand:(NSString*)command
                       parameter:(NSString*)parameter;
+// Register a display of the widget in the app_group NSUserDefaults.
+// Metrics on the widget usage will be sent (if enabled) on the next Chrome
+// startup.
+- (void)registerWidgetDisplay;
 
 @end
 
@@ -116,6 +121,7 @@
 
 - (void)viewWillAppear:(BOOL)animated {
   [super viewWillAppear:animated];
+  [self registerWidgetDisplay];
   [self updateWidget];
 }
 
@@ -213,6 +219,14 @@
   return [self openAppWithCommand:command parameter:nil];
 }
 
+- (void)registerWidgetDisplay {
+  NSUserDefaults* sharedDefaults = app_group::GetGroupUserDefaults();
+  NSInteger numberOfDisplay =
+      [sharedDefaults integerForKey:app_group::kSearchExtensionDisplayCount];
+  [sharedDefaults setInteger:numberOfDisplay + 1
+                      forKey:app_group::kSearchExtensionDisplayCount];
+}
+
 - (void)openAppWithCommand:(NSString*)command parameter:(NSString*)parameter {
   NSUserDefaults* sharedDefaults = app_group::GetGroupUserDefaults();
   NSString* defaultsKey =

ios/chrome/test/earl_grey/chrome_matchers.mm

diff --git a/ios/chrome/test/earl_grey/chrome_matchers.mm b/ios/chrome/test/earl_grey/chrome_matchers.mm
index f1669b5..99d95529 100644
--- a/ios/chrome/test/earl_grey/chrome_matchers.mm
+++ b/ios/chrome/test/earl_grey/chrome_matchers.mm
@@ -139,8 +139,7 @@
 }
 
 id<GREYMatcher> ToolsMenuButton() {
-  return grey_allOf(grey_accessibilityID(kToolbarToolsMenuButtonIdentifier),
-                    grey_sufficientlyVisible(), nil);
+  return ButtonWithAccessibilityLabelId(IDS_IOS_TOOLBAR_SETTINGS);
 }
 
 id<GREYMatcher> ShareButton() {

ios/clean/chrome/app/steps/root_coordinator+application_step.mm

diff --git a/ios/clean/chrome/app/steps/root_coordinator+application_step.mm b/ios/clean/chrome/app/steps/root_coordinator+application_step.mm
index fea3ab4..ac306df 100644
--- a/ios/clean/chrome/app/steps/root_coordinator+application_step.mm
+++ b/ios/clean/chrome/app/steps/root_coordinator+application_step.mm
@@ -8,6 +8,7 @@
 #include "base/supports_user_data.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #import "ios/chrome/browser/web_state_list/web_state_list.h"
+#import "ios/chrome/browser/web_state_list/web_state_opener.h"
 #import "ios/clean/chrome/app/application_state.h"
 #import "ios/shared/chrome/browser/ui/browser_list/browser.h"
 #import "ios/shared/chrome/browser/ui/browser_list/browser_list.h"
@@ -58,8 +59,10 @@
     WebStateList& webStateList = self.browser->web_state_list();
     web::WebState::CreateParams webStateCreateParams(
         self.browser->browser_state());
-    webStateList.InsertWebState(0, web::WebState::Create(webStateCreateParams));
-    webStateList.ActivateWebStateAt(0);
+    webStateList.InsertWebState(
+        0, web::WebState::Create(webStateCreateParams),
+        WebStateList::INSERT_FORCE_INDEX | WebStateList::INSERT_ACTIVATE,
+        WebStateOpener());
   }
 
   [self start];

ios/clean/chrome/browser/ui/tab/BUILD.gn

diff --git a/ios/clean/chrome/browser/ui/tab/BUILD.gn b/ios/clean/chrome/browser/ui/tab/BUILD.gn
index a94675d..5bc2d72 100644
--- a/ios/clean/chrome/browser/ui/tab/BUILD.gn
+++ b/ios/clean/chrome/browser/ui/tab/BUILD.gn
@@ -40,7 +40,9 @@
   ]
   deps = [
     "//base",
+    "//ios/chrome/browser/ui",
     "//ios/clean/chrome/browser/ui",
+    "//ios/clean/chrome/browser/ui/toolbar:toolbar_components_ui",
     "//ios/clean/chrome/browser/ui/transitions",
     "//ios/clean/chrome/browser/ui/transitions/animators",
     "//ios/clean/chrome/browser/ui/transitions/presenters",

ios/clean/chrome/browser/ui/tab/tab_container_view_controller.mm

diff --git a/ios/clean/chrome/browser/ui/tab/tab_container_view_controller.mm b/ios/clean/chrome/browser/ui/tab/tab_container_view_controller.mm
index d540889..bc5480f 100644
--- a/ios/clean/chrome/browser/ui/tab/tab_container_view_controller.mm
+++ b/ios/clean/chrome/browser/ui/tab/tab_container_view_controller.mm
@@ -5,6 +5,8 @@
 #import "ios/clean/chrome/browser/ui/tab/tab_container_view_controller.h"
 
 #import "base/logging.h"
+#import "ios/chrome/browser/ui/uikit_ui_util.h"
+#import "ios/clean/chrome/browser/ui/toolbar/toolbar_constants.h"
 #import "ios/clean/chrome/browser/ui/transitions/animators/swap_from_above_animator.h"
 #import "ios/clean/chrome/browser/ui/transitions/containment_transition_context.h"
 #import "ios/clean/chrome/browser/ui/transitions/containment_transitioning_delegate.h"
@@ -28,6 +30,11 @@
 @property(nonatomic, strong) UIView* toolbarView;
 @property(nonatomic, strong) UIView* contentView;
 
+// Status Bar background view. Its size is directly linked to the difference
+// between this VC's view topLayoutGuide top anchor and bottom anchor. This
+// means that this view will not be displayed on landscape.
+@property(nonatomic, strong) UIView* statusBarBackgroundView;
+
 // Height constraints for tabStripView and toolbarView.
 @property(nonatomic, strong) NSLayoutConstraint* tabStripHeightConstraint;
 @property(nonatomic, strong) NSLayoutConstraint* toolbarHeightConstraint;
@@ -49,6 +56,7 @@
 @synthesize tabStripView = _tabStripView;
 @synthesize toolbarView = _toolbarView;
 @synthesize contentView = _contentView;
+@synthesize statusBarBackgroundView = _statusBarBackgroundView;
 @synthesize tabStripHeightConstraint = _tabStripHeightConstraint;
 @synthesize toolbarHeightConstraint = _toolbarHeightConstraint;
 @synthesize containmentTransitioningDelegate =
@@ -63,19 +71,24 @@
   self.tabStripView = [[UIView alloc] init];
   self.toolbarView = [[UIView alloc] init];
   self.contentView = [[UIView alloc] init];
+  self.statusBarBackgroundView = [[UIView alloc] init];
   self.findBarView.translatesAutoresizingMaskIntoConstraints = NO;
   self.tabStripView.translatesAutoresizingMaskIntoConstraints = NO;
   self.toolbarView.translatesAutoresizingMaskIntoConstraints = NO;
   self.contentView.translatesAutoresizingMaskIntoConstraints = NO;
+  self.statusBarBackgroundView.translatesAutoresizingMaskIntoConstraints = NO;
   self.view.backgroundColor = [UIColor blackColor];
   self.findBarView.backgroundColor = [UIColor clearColor];
   self.tabStripView.backgroundColor = [UIColor blackColor];
   self.toolbarView.backgroundColor = [UIColor blackColor];
   self.contentView.backgroundColor = [UIColor blackColor];
+  self.statusBarBackgroundView.backgroundColor =
+      UIColorFromRGB(kToolbarBackgroundColor);
   self.findBarView.clipsToBounds = YES;
 
   // Views that are added last have the highest z-order.
   [self.view addSubview:self.tabStripView];
+  [self.view addSubview:self.statusBarBackgroundView];
   [self.view addSubview:self.toolbarView];
   [self.view addSubview:self.contentView];
   [self.view addSubview:self.findBarView];
@@ -249,6 +262,15 @@
 // Override with constraints that place the toolbar on top.
 - (Constraints*)subviewConstraints {
   return @[
+    [self.statusBarBackgroundView.topAnchor
+        constraintEqualToAnchor:self.topLayoutGuide.topAnchor],
+    [self.statusBarBackgroundView.bottomAnchor
+        constraintEqualToAnchor:self.topLayoutGuide.bottomAnchor],
+    [self.statusBarBackgroundView.leadingAnchor
+        constraintEqualToAnchor:self.view.leadingAnchor],
+    [self.statusBarBackgroundView.trailingAnchor
+        constraintEqualToAnchor:self.view.trailingAnchor],
+
     [self.tabStripView.topAnchor
         constraintEqualToAnchor:self.topLayoutGuide.bottomAnchor],
     [self.tabStripView.leadingAnchor
@@ -290,6 +312,15 @@
 // Override with constraints that place the toolbar on bottom.
 - (Constraints*)subviewConstraints {
   return @[
+    [self.statusBarBackgroundView.topAnchor
+        constraintEqualToAnchor:self.topLayoutGuide.topAnchor],
+    [self.statusBarBackgroundView.bottomAnchor
+        constraintEqualToAnchor:self.topLayoutGuide.bottomAnchor],
+    [self.statusBarBackgroundView.leadingAnchor
+        constraintEqualToAnchor:self.view.leadingAnchor],
+    [self.statusBarBackgroundView.trailingAnchor
+        constraintEqualToAnchor:self.view.trailingAnchor],
+
     [self.tabStripView.topAnchor
         constraintEqualToAnchor:self.topLayoutGuide.bottomAnchor],
     [self.tabStripView.leadingAnchor

ios/clean/chrome/browser/ui/tab_collection/tab_collection_mediator_unittest.mm

diff --git a/ios/clean/chrome/browser/ui/tab_collection/tab_collection_mediator_unittest.mm b/ios/clean/chrome/browser/ui/tab_collection/tab_collection_mediator_unittest.mm
index a9f98df..ec5ca581 100644
--- a/ios/clean/chrome/browser/ui/tab_collection/tab_collection_mediator_unittest.mm
+++ b/ios/clean/chrome/browser/ui/tab_collection/tab_collection_mediator_unittest.mm
@@ -10,6 +10,7 @@
 #include "ios/chrome/browser/web_state_list/fake_web_state_list_delegate.h"
 #include "ios/chrome/browser/web_state_list/web_state_list.h"
 #import "ios/chrome/browser/web_state_list/web_state_list_observer_bridge.h"
+#import "ios/chrome/browser/web_state_list/web_state_opener.h"
 #import "ios/clean/chrome/browser/ui/tab_collection/tab_collection_consumer.h"
 #import "ios/web/public/test/fakes/test_navigation_manager.h"
 #import "ios/web/public/test/fakes/test_web_state.h"
@@ -49,7 +50,9 @@
     TabIdTabHelper::CreateForWebState(web_state.get());
     GURL url("http://test/" + std::to_string(index));
     web_state->SetCurrentURL(url);
-    web_state_list_->InsertWebState(index, std::move(web_state));
+    web_state_list_->InsertWebState(index, std::move(web_state),
+                                    WebStateList::INSERT_FORCE_INDEX,
+                                    WebStateOpener());
   }
 
   web::TestWebState* GetWebStateAt(int index) {

ios/clean/chrome/browser/ui/tab_grid/tab_grid_coordinator.mm

diff --git a/ios/clean/chrome/browser/ui/tab_grid/tab_grid_coordinator.mm b/ios/clean/chrome/browser/ui/tab_grid/tab_grid_coordinator.mm
index b55d3a9..fe0a209 100644
--- a/ios/clean/chrome/browser/ui/tab_grid/tab_grid_coordinator.mm
+++ b/ios/clean/chrome/browser/ui/tab_grid/tab_grid_coordinator.mm
@@ -12,6 +12,7 @@
 #import "ios/chrome/browser/snapshots/snapshot_cache_factory.h"
 #import "ios/chrome/browser/ui/tools_menu/tools_menu_configuration.h"
 #import "ios/chrome/browser/web_state_list/web_state_list.h"
+#import "ios/chrome/browser/web_state_list/web_state_opener.h"
 #import "ios/clean/chrome/browser/ui/commands/context_menu_commands.h"
 #import "ios/clean/chrome/browser/ui/commands/settings_commands.h"
 #import "ios/clean/chrome/browser/ui/commands/tab_grid_commands.h"
@@ -179,8 +180,9 @@
   std::unique_ptr<web::WebState> webState =
       web::WebState::Create(webStateCreateParams);
   webState->SetWebUsageEnabled(true);
-  self.webStateList.InsertWebState(self.webStateList.count(),
-                                   std::move(webState));
+  self.webStateList.InsertWebState(
+      self.webStateList.count(), std::move(webState),
+      WebStateList::INSERT_FORCE_INDEX, WebStateOpener());
   [self showTabGridTabAtIndex:self.webStateList.count() - 1];
 }
 

ios/clean/chrome/browser/ui/tab_grid/tab_grid_mediator_unittest.mm

diff --git a/ios/clean/chrome/browser/ui/tab_grid/tab_grid_mediator_unittest.mm b/ios/clean/chrome/browser/ui/tab_grid/tab_grid_mediator_unittest.mm
index 10ddab36..1b3aae9 100644
--- a/ios/clean/chrome/browser/ui/tab_grid/tab_grid_mediator_unittest.mm
+++ b/ios/clean/chrome/browser/ui/tab_grid/tab_grid_mediator_unittest.mm
@@ -9,6 +9,7 @@
 #include "ios/chrome/browser/web_state_list/fake_web_state_list_delegate.h"
 #include "ios/chrome/browser/web_state_list/web_state_list.h"
 #import "ios/chrome/browser/web_state_list/web_state_list_observer_bridge.h"
+#import "ios/chrome/browser/web_state_list/web_state_opener.h"
 #import "ios/clean/chrome/browser/ui/tab_grid/tab_grid_consumer.h"
 #import "ios/web/public/test/fakes/test_navigation_manager.h"
 #import "ios/web/public/test/fakes/test_web_state.h"
@@ -39,7 +40,9 @@
   void InsertWebStateAt(int index) {
     auto web_state = base::MakeUnique<web::TestWebState>();
     TabIdTabHelper::CreateForWebState(web_state.get());
-    web_state_list_->InsertWebState(index, std::move(web_state));
+    web_state_list_->InsertWebState(index, std::move(web_state),
+                                    WebStateList::INSERT_FORCE_INDEX,
+                                    WebStateOpener());
   }
 
   void SetConsumer() {

ios/clean/chrome/browser/ui/toolbar/toolbar_mediator_unittest.mm

diff --git a/ios/clean/chrome/browser/ui/toolbar/toolbar_mediator_unittest.mm b/ios/clean/chrome/browser/ui/toolbar/toolbar_mediator_unittest.mm
index ef05ddd0..3d15c20 100644
--- a/ios/clean/chrome/browser/ui/toolbar/toolbar_mediator_unittest.mm
+++ b/ios/clean/chrome/browser/ui/toolbar/toolbar_mediator_unittest.mm
@@ -10,6 +10,7 @@
 #include "ios/chrome/browser/web_state_list/fake_web_state_list_delegate.h"
 #include "ios/chrome/browser/web_state_list/web_state_list.h"
 #import "ios/chrome/browser/web_state_list/web_state_list_observer_bridge.h"
+#import "ios/chrome/browser/web_state_list/web_state_opener.h"
 #import "ios/clean/chrome/browser/ui/toolbar/toolbar_consumer.h"
 #import "ios/web/public/test/fakes/test_navigation_manager.h"
 #import "ios/web/public/test/fakes/test_web_state.h"
@@ -54,15 +55,17 @@
   void SetUpWebStateList() {
     web_state_list_ = base::MakeUnique<WebStateList>(&web_state_list_delegate_);
     for (int i = 0; i < kNumberOfWebStates; i++) {
-      InsertWebState(i);
+      InsertNewWebState(i);
     }
   }
 
-  void InsertWebState(int index) {
+  void InsertNewWebState(int index) {
     auto web_state = base::MakeUnique<web::TestWebState>();
     GURL url("http://test/" + std::to_string(index));
     web_state->SetCurrentURL(url);
-    web_state_list_->InsertWebState(index, std::move(web_state));
+    web_state_list_->InsertWebState(index, std::move(web_state),
+                                    WebStateList::INSERT_FORCE_INDEX,
+                                    WebStateOpener());
   }
 
   TestToolbarMediator* mediator_;
@@ -209,7 +212,7 @@
   mediator_.webStateList = web_state_list_.get();
   mediator_.consumer = consumer_;
 
-  InsertWebState(0);
+  InsertNewWebState(0);
   [[consumer_ verify] setTabCount:kNumberOfWebStates + 1];
 }
 

net/BUILD.gn

diff --git a/net/BUILD.gn b/net/BUILD.gn
index b5931635..1288ecc 100644
--- a/net/BUILD.gn
+++ b/net/BUILD.gn
@@ -2524,6 +2524,8 @@
     "dns/mock_host_resolver.h",
     "dns/mock_mdns_socket_factory.cc",
     "dns/mock_mdns_socket_factory.h",
+    "filter/filter_source_stream_test_util.cc",
+    "filter/filter_source_stream_test_util.h",
     "filter/mock_source_stream.cc",
     "filter/mock_source_stream.h",
     "http/http_stream_factory_test_util.cc",
@@ -2634,7 +2636,9 @@
     "//url",
   ]
 
-  deps = []
+  deps = [
+    "//third_party/zlib",
+  ]
 
   data = [
     "data/",
@@ -4759,8 +4763,6 @@
     "extras/sqlite/sqlite_channel_id_store_unittest.cc",
     "extras/sqlite/sqlite_persistent_cookie_store_unittest.cc",
     "filter/brotli_source_stream_unittest.cc",
-    "filter/filter_source_stream_test_util.cc",
-    "filter/filter_source_stream_test_util.h",
     "filter/filter_source_stream_unittest.cc",
     "filter/gzip_source_stream_unittest.cc",
     "filter/sdch_policy_delegate_unittest.cc",

net/test/embedded_test_server/default_handlers.cc

diff --git a/net/test/embedded_test_server/default_handlers.cc b/net/test/embedded_test_server/default_handlers.cc
index fd30421..34285f6 100644
--- a/net/test/embedded_test_server/default_handlers.cc
+++ b/net/test/embedded_test_server/default_handlers.cc
@@ -10,6 +10,7 @@
 #include <sstream>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ -28,6 +29,7 @@
 #include "base/time/time.h"
 #include "net/base/escape.h"
 #include "net/base/url_util.h"
+#include "net/filter/filter_source_stream_test_util.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/test/embedded_test_server/request_handler_util.h"
@@ -640,6 +642,30 @@
   return base::MakeUnique<HungAfterHeadersHttpResponse>();
 }
 
+// /gzip-body?<body>
+// Returns a response with a gzipped body of "<body>". Attempts to allocate
+// enough memory to contain the body, but DCHECKs if that fails.
+std::unique_ptr<HttpResponse> HandleGzipBody(const HttpRequest& request) {
+  std::string uncompressed_body = request.GetURL().query();
+  // Attempt to pick size that's large enough even in the worst case (deflate
+  // block headers should be shorter than 512 bytes, and deflating should never
+  // double size of data, modulo headers).
+  // TODO(mmenke): This is rather awkward. Worth improving CompressGzip?
+  std::vector<char> compressed_body(uncompressed_body.size() * 2 + 512);
+  size_t compressed_size = compressed_body.size();
+  CompressGzip(uncompressed_body.c_str(), uncompressed_body.size(),
+               compressed_body.data(), &compressed_size,
+               true /* gzip_framing */);
+  // CompressGzip should DCHECK itself if this fails, anyways.
+  DCHECK_GE(compressed_body.size(), compressed_size);
+
+  std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+  http_response->set_content(
+      std::string(compressed_body.data(), compressed_size));
+  http_response->AddCustomHeader("Content-Encoding", "gzip");
+  return std::move(http_response);
+}
+
 }  // anonymous namespace
 
 #define PREFIXED_HANDLER(prefix, handler) \
@@ -687,6 +713,8 @@
       PREFIXED_HANDLER("/hung", &HandleHungResponse));
   server->RegisterDefaultHandler(
       PREFIXED_HANDLER("/hung-after-headers", &HandleHungAfterHeadersResponse));
+  server->RegisterDefaultHandler(
+      PREFIXED_HANDLER("/gzip-body", &HandleGzipBody));
 
   // TODO(svaldez): HandleDownload
   // TODO(svaldez): HandleDownloadFinish

pdf/pdfium/pdfium_engine.cc

diff --git a/pdf/pdfium/pdfium_engine.cc b/pdf/pdfium/pdfium_engine.cc
index ae21dcd..3652fd2d 100644
--- a/pdf/pdfium/pdfium_engine.cc
+++ b/pdf/pdfium/pdfium_engine.cc
@@ -1790,10 +1790,27 @@
     double page_y;
     DeviceToPage(page_index, point.x(), point.y(), &page_x, &page_y);
 
-    FPDF_PAGE page = pages_[page_index]->GetPage();
-    FORM_OnLButtonDown(form_, page, 0, page_x, page_y);
+    bool is_form_text_area = false;
     if (form_type != FPDF_FORMFIELD_UNKNOWN) {
       DCHECK_EQ(area, PDFiumPage::FormTypeToArea(form_type));
+      is_form_text_area = area == PDFiumPage::FORM_TEXT_AREA;
+    }
+
+    FPDF_PAGE page = pages_[page_index]->GetPage();
+    bool is_editable_form_text_area = false;
+    if (is_form_text_area) {
+      FPDF_ANNOTATION annot =
+          FPDFAnnot_GetFormFieldAtPoint(form_, page, page_x, page_y);
+      DCHECK(annot);
+
+      int flags = FPDFAnnot_GetFormFieldFlags(page, annot);
+      is_editable_form_text_area =
+          CheckIfEditableFormTextArea(flags, form_type);
+      FPDFPage_CloseAnnot(annot);
+    }
+
+    FORM_OnLButtonDown(form_, page, 0, page_x, page_y);
+    if (form_type != FPDF_FORMFIELD_UNKNOWN) {
       // Destroy SelectionChangeInvalidator object before SetInFormTextArea()
       // changes plugin's focus to be in form text area. This way, regular text
       // selection can be cleared when a user clicks into a form text area
@@ -1802,17 +1819,8 @@
       // (not the Renderer).
       selection_invalidator.reset();
 
-      bool is_form_text_area = area == PDFiumPage::FORM_TEXT_AREA;
       SetInFormTextArea(is_form_text_area);
-      if (is_form_text_area) {
-        FPDF_ANNOTATION annot =
-            FPDFAnnot_GetFormFieldAtPoint(form_, page, page_x, page_y);
-        DCHECK(annot);
-        int flags = FPDFAnnot_GetFormFieldFlags(page, annot);
-        editable_form_text_area_ =
-            CheckIfEditableFormTextArea(flags, form_type);
-        FPDFPage_CloseAnnot(annot);
-      }
+      editable_form_text_area_ = is_editable_form_text_area;
       return true;  // Return now before we get into the selection code.
     }
   }

sandbox/win/src/win_utils.cc

diff --git a/sandbox/win/src/win_utils.cc b/sandbox/win/src/win_utils.cc
index 51ae51d..054567a 100644
--- a/sandbox/win/src/win_utils.cc
+++ b/sandbox/win/src/win_utils.cc
@@ -23,6 +23,14 @@
 
 namespace {
 
+const size_t kDriveLetterLen = 3;
+
+constexpr wchar_t kNTDotPrefix[] = L"\\\\.\\";
+const size_t kNTDotPrefixLen = arraysize(kNTDotPrefix) - 1;
+
+constexpr wchar_t kWIN32Prefix[] = L"\\\\?\\";
+const size_t kWIN32PrefixLen = arraysize(kWIN32Prefix) - 1;
+
 // Holds the information about a known registry key.
 struct KnownReservedKey {
   const wchar_t* name;
@@ -47,6 +55,12 @@
   return _wcsicmp(first.c_str(), second.c_str()) == 0;
 }
 
+bool EqualPath(const base::string16& first,
+               const base::string16& second,
+               size_t len) {
+  return _wcsnicmp(first.c_str(), second.c_str(), len) == 0;
+}
+
 bool EqualPath(const base::string16& first, size_t first_offset,
                const base::string16& second, size_t second_offset) {
   return _wcsicmp(first.c_str() + first_offset,
@@ -65,9 +79,9 @@
 
 // Returns true if |path| starts with "\??\" and returns a path without that
 // component.
-bool IsNTPath(const base::string16& path, base::string16* trimmed_path ) {
+bool IsNTPath(const base::string16& path, base::string16* trimmed_path) {
   if ((path.size() < sandbox::kNTPrefixLen) ||
-      (0 != path.compare(0, sandbox::kNTPrefixLen, sandbox::kNTPrefix))) {
+      !EqualPath(path, sandbox::kNTPrefix, sandbox::kNTPrefixLen)) {
     *trimmed_path = path;
     return false;
   }
@@ -78,7 +92,7 @@
 
 // Returns true if |path| starts with "\Device\" and returns a path without that
 // component.
-bool IsDevicePath(const base::string16& path, base::string16* trimmed_path ) {
+bool IsDevicePath(const base::string16& path, base::string16* trimmed_path) {
   if ((path.size() < sandbox::kNTDevicePrefixLen) ||
       (!EqualPath(path, sandbox::kNTDevicePrefix,
                   sandbox::kNTDevicePrefixLen))) {
@@ -90,8 +104,38 @@
   return true;
 }
 
+// Returns the offset to the path seperator following
+// "\Device\HarddiskVolumeX" in |path|.
+size_t PassHarddiskVolume(const base::string16& path) {
+  static constexpr wchar_t pattern[] = L"\\Device\\HarddiskVolume";
+  const size_t patternLen = arraysize(pattern) - 1;
+
+  // First, check for |pattern|.
+  if ((path.size() < patternLen) || (!EqualPath(path, pattern, patternLen)))
+    return base::string16::npos;
+
+  // Find the next path separator, after the pattern match.
+  return path.find_first_of(L'\\', patternLen - 1);
+}
+
+// Returns true if |path| starts with "\Device\HarddiskVolumeX\" and returns a
+// path without that component.  |removed| will hold the prefix removed.
+bool IsDeviceHarddiskPath(const base::string16& path,
+                          base::string16* trimmed_path,
+                          base::string16* removed) {
+  size_t offset = PassHarddiskVolume(path);
+  if (offset == base::string16::npos)
+    return false;
+
+  // Remove up to and including the path separator.
+  *removed = path.substr(0, offset + 1);
+  // Remaining path starts after the path separator.
+  *trimmed_path = path.substr(offset + 1);
+  return true;
+}
+
 bool StartsWithDriveLetter(const base::string16& path) {
-  if (path.size() < 3)
+  if (path.size() < kDriveLetterLen)
     return false;
 
   if (path[1] != L':' || path[2] != L'\\')
@@ -100,29 +144,57 @@
   return base::IsAsciiAlpha(path[0]);
 }
 
-const wchar_t kNTDotPrefix[] = L"\\\\.\\";
-const size_t kNTDotPrefixLen = arraysize(kNTDotPrefix) - 1;
-
 // Removes "\\\\.\\" from the path.
 void RemoveImpliedDevice(base::string16* path) {
-  if (0 == path->compare(0, kNTDotPrefixLen, kNTDotPrefix))
+  if (EqualPath(*path, kNTDotPrefix, kNTDotPrefixLen))
     *path = path->substr(kNTDotPrefixLen);
 }
 
-// Get the native path to the process.
-bool GetProcessPath(HANDLE process, base::string16* path) {
+// Get drive letter from a Win32 path (if it's there).
+// - Returns 'false' if no drive letter is found.
+bool GetDriveLetter(const base::string16& win32_path,
+                    base::string16* drive_letter) {
+  base::string16 temp = win32_path;
+
+  if (win32_path.size() >= kWIN32PrefixLen &&
+      EqualPath(win32_path, kWIN32Prefix, kWIN32PrefixLen)) {
+    // Bypass Win32 file prefix ("\\?\") if it's there.
+    temp = win32_path.substr(kWIN32PrefixLen);
+  } else if (win32_path.size() >= kNTDotPrefixLen &&
+             EqualPath(win32_path, kNTDotPrefix, kNTDotPrefixLen)) {
+    // Bypass Win32 device prefix ("\\.\") if it's there.
+    temp = win32_path.substr(kNTDotPrefixLen);
+  } else if (win32_path.size() >= sandbox::kNTPrefixLen &&
+             EqualPath(win32_path, sandbox::kNTPrefix, sandbox::kNTPrefixLen)) {
+    // Bypass object manager prefix ("\??\") if it's there.
+    temp = win32_path.substr(sandbox::kNTPrefixLen);
+  }
+
+  if (!StartsWithDriveLetter(temp)) {
+    drive_letter->clear();
+    return false;
+  }
+
+  drive_letter->assign(temp, 0, kDriveLetterLen);
+  return true;
+}
+
+// Get the path to the process.
+// - Pass 'true' for native format, or 'false' for win32.
+// - Returns the full name of the exe image for |process|.
+bool GetProcessPath(HANDLE process, base::string16* path, bool native) {
   wchar_t process_name[MAX_PATH];
   DWORD size = MAX_PATH;
-  if (::QueryFullProcessImageNameW(process, PROCESS_NAME_NATIVE, process_name,
-                                   &size)) {
+  DWORD flags = (native) ? PROCESS_NAME_NATIVE : 0;
+  if (::QueryFullProcessImageNameW(process, flags, process_name, &size)) {
     *path = process_name;
     return true;
   }
   // Process name is potentially greater than MAX_PATH, try larger max size.
   std::vector<wchar_t> process_name_buffer(SHRT_MAX);
   size = SHRT_MAX;
-  if (::QueryFullProcessImageNameW(process, PROCESS_NAME_NATIVE,
-                                   &process_name_buffer[0], &size)) {
+  if (::QueryFullProcessImageNameW(process, flags, &process_name_buffer[0],
+                                   &size)) {
     *path = &process_name_buffer[0];
     return true;
   }
@@ -155,7 +227,7 @@
 // Returns true if the provided path points to a pipe.
 bool IsPipe(const base::string16& path) {
   size_t start = 0;
-  if (0 == path.compare(0, sandbox::kNTPrefixLen, sandbox::kNTPrefix))
+  if (EqualPath(path, sandbox::kNTPrefix, sandbox::kNTPrefixLen))
     start = sandbox::kNTPrefixLen;
 
   const wchar_t kPipe[] = L"pipe\\";
@@ -319,21 +391,42 @@
   return true;
 }
 
-// Paths like \Device\HarddiskVolume0\some\foo\bar are assumed to be already
-// expanded.
-bool ConvertToLongPath(base::string16* path) {
-  if (IsPipe(*path))
+// Just make a best effort here.  There are lots of corner cases that we're
+// not expecting - and will fail to make long.
+bool ConvertToLongPath(base::string16* native_path,
+                       const base::string16* drive_letter) {
+  if (IsPipe(*native_path))
     return true;
 
-  base::string16 temp_path;
-  if (IsDevicePath(*path, &temp_path))
-    return false;
-
-  bool is_nt_path = IsNTPath(temp_path, &temp_path);
+  bool is_device_harddisk_path = false;
+  bool is_nt_path = false;
   bool added_implied_device = false;
-  if (!StartsWithDriveLetter(temp_path) && is_nt_path) {
-    temp_path = base::string16(kNTDotPrefix) + temp_path;
-    added_implied_device = true;
+  base::string16 temp_path;
+  base::string16 to_restore;
+
+  // Process a few prefix types.
+  if (IsNTPath(*native_path, &temp_path)) {
+    // "\??\"
+    if (!StartsWithDriveLetter(temp_path)) {
+      // Prepend with "\\.\".
+      temp_path = base::string16(kNTDotPrefix) + temp_path;
+      added_implied_device = true;
+    }
+    is_nt_path = true;
+  } else if (IsDeviceHarddiskPath(*native_path, &temp_path, &to_restore)) {
+    // "\Device\HarddiskVolumeX\" - hacky attempt making ::GetLongPathName
+    // work for native device paths.  Remove "\Device\HarddiskVolumeX\" and
+    // replace with drive letter.
+
+    // Nothing we can do if we don't have a drive letter.  Leave |native_path|
+    // as is.
+    if (!drive_letter || drive_letter->empty())
+      return false;
+    temp_path = *drive_letter + temp_path;
+    is_device_harddisk_path = true;
+  } else if (IsDevicePath(*native_path, &temp_path)) {
+    // "\Device\" - there's nothing we can do to convert to long here.
+    return false;
   }
 
   DWORD size = MAX_PATH;
@@ -369,15 +462,21 @@
     temp_path = long_path_buf.get();
   }
 
+  // If successful, re-apply original namespace prefix before returning.
   if (return_value != 0) {
     if (added_implied_device)
       RemoveImpliedDevice(&temp_path);
 
     if (is_nt_path) {
-      *path = kNTPrefix;
-      *path += temp_path;
+      *native_path = kNTPrefix;
+      *native_path += temp_path;
+    } else if (is_device_harddisk_path) {
+      // Remove the added drive letter.
+      temp_path = temp_path.substr(kDriveLetterLen);
+      *native_path = to_restore;
+      *native_path += temp_path;
     } else {
-      *path = temp_path;
+      *native_path = temp_path;
     }
 
     return true;
@@ -469,7 +568,17 @@
   void* current = reinterpret_cast<void*>(0x10000);
   base::string16 process_path;
 
-  if (!GetProcessPath(process, &process_path))
+  // First, get the win32 process path.
+  if (!GetProcessPath(process, &process_path, false))
+    return nullptr;
+
+  // Next, get the drive letter from the win32 path. (May not be one.)
+  base::string16 drive;
+  GetDriveLetter(process_path, &drive);
+
+  // Now get the native process path.
+  // (Currently assuming QueryFullProcessImageName returns long format.)
+  if (!GetProcessPath(process, &process_path, true))
     return nullptr;
 
   // Walk the virtual memory mappings trying to find image sections.
@@ -478,9 +587,19 @@
   while (::VirtualQueryEx(process, current, &mem_info, sizeof(mem_info))) {
     base::string16 image_path;
     if (mem_info.Type == MEM_IMAGE &&
-        GetImageFilePath(process, mem_info.BaseAddress, &image_path) &&
-        EqualPath(process_path, image_path)) {
-      return mem_info.BaseAddress;
+        GetImageFilePath(process, mem_info.BaseAddress, &image_path)) {
+      // Compare HarddiskVolume before doing any more work.
+      size_t offset = PassHarddiskVolume(process_path);
+      if (offset != base::string16::npos &&
+          EqualPath(process_path, image_path, offset + 1)) {
+        // Native file paths returned from GetImageFilePath can be in short/8.3
+        // form, depending on filesystem.
+        ConvertToLongPath(&image_path, &drive);
+        // Compare the rest of the two paths.
+        if (EqualPath(process_path, offset + 1, image_path, offset + 1)) {
+          return mem_info.BaseAddress;
+        }
+      }
     }
     // VirtualQueryEx should fail before overflow, but just in case we'll check
     // to prevent an infinite loop.

sandbox/win/src/win_utils.h

diff --git a/sandbox/win/src/win_utils.h b/sandbox/win/src/win_utils.h
index b88b08c..76f6c36 100644
--- a/sandbox/win/src/win_utils.h
+++ b/sandbox/win/src/win_utils.h
@@ -69,7 +69,10 @@
 // Convert a short path (C:\path~1 or \\??\\c:\path~1) to the long version of
 // the path. If the path is not a valid filesystem path, the function returns
 // false and argument is not modified.
-bool ConvertToLongPath(base::string16* path);
+// - If passing in a short native device path (\Device\HarddiskVolumeX\path~1),
+//   a drive letter string (c:\) must also be provided.
+bool ConvertToLongPath(base::string16* path,
+                       const base::string16* drive_letter = nullptr);
 
 // Returns ERROR_SUCCESS if the path contains a reparse point,
 // ERROR_NOT_A_REPARSE_POINT if there's no reparse point in this path, or an

sandbox/win/src/win_utils_unittest.cc

diff --git a/sandbox/win/src/win_utils_unittest.cc b/sandbox/win/src/win_utils_unittest.cc
index 50ded51..fa3e5888 100644
--- a/sandbox/win/src/win_utils_unittest.cc
+++ b/sandbox/win/src/win_utils_unittest.cc
@@ -7,7 +7,10 @@
 
 #include <vector>
 
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/path_service.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_process_information.h"
 #include "sandbox/win/src/nt_internals.h"
@@ -208,4 +211,59 @@
   }
   EXPECT_EQ(base_address,
             GetProcessBaseAddress(scoped_proc_info.process_handle()));
+}
+
+// This test requires an elevated prompt to setup.
+TEST(WinUtils, ConvertToLongPath) {
+  // Test setup.
+  base::FilePath orig_path;
+  ASSERT_TRUE(base::PathService::Get(base::DIR_SYSTEM, &orig_path));
+  orig_path = orig_path.Append(L"calc.exe");
+
+  base::FilePath temp_path;
+  ASSERT_TRUE(base::PathService::Get(base::DIR_PROGRAM_FILES, &temp_path));
+  temp_path = temp_path.Append(L"test_calc.exe");
+
+  ASSERT_TRUE(base::CopyFile(orig_path, temp_path));
+  // No more asserts until cleanup.
+
+  // WIN32 long path: "c:\Program Files\test_calc.exe"
+  wchar_t short_path[MAX_PATH] = {};
+  DWORD size =
+      ::GetShortPathNameW(temp_path.value().c_str(), short_path, MAX_PATH);
+  EXPECT_TRUE(size > 0 && size < MAX_PATH);
+  // WIN32 short path: "C:\PROGRA~1\TEST_C~1.exe"
+
+  // Sanity check that we actually got a short path above!  Small chance
+  // it was disabled in the filesystem setup.
+  EXPECT_NE(temp_path.value().length(), ::wcslen(short_path));
+
+  base::string16 short_form_native_path;
+  EXPECT_TRUE(sandbox::GetNtPathFromWin32Path(base::string16(short_path),
+                                              &short_form_native_path));
+  // NT short path: "\Device\HarddiskVolume4\PROGRA~1\TEST_C~1.EXE"
+
+  // Test 1: convert win32 short path to long:
+  base::string16 test1(short_path);
+  EXPECT_TRUE(sandbox::ConvertToLongPath(&test1));
+  EXPECT_TRUE(::wcsicmp(temp_path.value().c_str(), test1.c_str()) == 0);
+  // Expected result: "c:\Program Files\test_calc.exe"
+
+  // Test 2: convert native short path to long:
+  base::string16 drive_letter = temp_path.value().substr(0, 3);
+  base::string16 test2(short_form_native_path);
+  EXPECT_TRUE(sandbox::ConvertToLongPath(&test2, &drive_letter));
+
+  size_t index = short_form_native_path.find_first_of(
+      L'\\', ::wcslen(L"\\Device\\HarddiskVolume"));
+  EXPECT_TRUE(index != base::string16::npos);
+  base::string16 expected_result = short_form_native_path.substr(0, index + 1);
+  expected_result.append(temp_path.value().substr(3));
+  EXPECT_TRUE(::wcsicmp(expected_result.c_str(), test2.c_str()) == 0);
+  // Expected result: "\Device\HarddiskVolumeX\Program Files\test_calc.exe"
+
+  // clean up
+  EXPECT_TRUE(base::DeleteFileW(temp_path, false));
+
+  return;
 }
\ No newline at end of file

services/ui/public/interfaces/window_tree.mojom

diff --git a/services/ui/public/interfaces/window_tree.mojom b/services/ui/public/interfaces/window_tree.mojom
index 14299b29..fef44bc 100644
--- a/services/ui/public/interfaces/window_tree.mojom
+++ b/services/ui/public/interfaces/window_tree.mojom
@@ -7,8 +7,8 @@
 import "cc/ipc/frame_sink_id.mojom";
 import "cc/ipc/local_surface_id.mojom";
 import "cc/ipc/surface_id.mojom";
-import "cc/ipc/surface_info.mojom";
 import "services/viz/public/interfaces/compositing/compositor_frame_sink.mojom";
+import "services/viz/public/interfaces/compositing/surface_info.mojom";
 import "services/ui/public/interfaces/cursor/cursor.mojom";
 import "services/ui/public/interfaces/event_matcher.mojom";
 import "services/ui/public/interfaces/mus_constants.mojom";
@@ -485,7 +485,7 @@
   // TODO(fsamuel): Surface IDs should be passed to parents directly instead of
   // going through the window server. http://crbug.com/655231
   OnWindowSurfaceChanged(uint32 window_id,
-                         cc.mojom.SurfaceInfo surface_info);
+                         viz.mojom.SurfaceInfo surface_info);
 
   // Called when the mouse cursor enters a window on this connection for the
   // first time, providing a list of available mime types. We want to send this

services/ui/ws/compositor_frame_sink_client_binding.cc

diff --git a/services/ui/ws/compositor_frame_sink_client_binding.cc b/services/ui/ws/compositor_frame_sink_client_binding.cc
index 264adb4b..a869302 100644
--- a/services/ui/ws/compositor_frame_sink_client_binding.cc
+++ b/services/ui/ws/compositor_frame_sink_client_binding.cc
@@ -26,7 +26,8 @@
 void CompositorFrameSinkClientBinding::SubmitCompositorFrame(
     const viz::LocalSurfaceId& local_surface_id,
     cc::CompositorFrame frame,
-    viz::mojom::HitTestRegionListPtr hit_test_region_list) {
+    viz::mojom::HitTestRegionListPtr hit_test_region_list,
+    uint64_t submit_time) {
   if (local_surface_id != local_surface_id_) {
     local_surface_id_ = local_surface_id;
     gfx::Size frame_size = frame.render_pass_list.back()->output_rect.size();
@@ -35,7 +36,8 @@
                                         frame.metadata.device_scale_factor);
   }
   compositor_frame_sink_->SubmitCompositorFrame(
-      local_surface_id_, std::move(frame), std::move(hit_test_region_list));
+      local_surface_id_, std::move(frame), std::move(hit_test_region_list),
+      submit_time);
 }
 
 void CompositorFrameSinkClientBinding::DidNotProduceFrame(

services/ui/ws/compositor_frame_sink_client_binding.h

diff --git a/services/ui/ws/compositor_frame_sink_client_binding.h b/services/ui/ws/compositor_frame_sink_client_binding.h
index 7228ca89..40d05c0 100644
--- a/services/ui/ws/compositor_frame_sink_client_binding.h
+++ b/services/ui/ws/compositor_frame_sink_client_binding.h
@@ -33,7 +33,8 @@
   void SubmitCompositorFrame(
       const viz::LocalSurfaceId& local_surface_id,
       cc::CompositorFrame frame,
-      viz::mojom::HitTestRegionListPtr hit_test_region_list) override;
+      viz::mojom::HitTestRegionListPtr hit_test_region_list,
+      uint64_t submit_time) override;
   void SetNeedsBeginFrame(bool needs_begin_frame) override;
   void DidNotProduceFrame(const viz::BeginFrameAck& ack) override;
 

services/ui/ws/frame_generator.cc

diff --git a/services/ui/ws/frame_generator.cc b/services/ui/ws/frame_generator.cc
index d3f48ee..5d2bbc8 100644
--- a/services/ui/ws/frame_generator.cc
+++ b/services/ui/ws/frame_generator.cc
@@ -109,7 +109,7 @@
     local_surface_id_ = id_allocator_.GenerateId();
   }
   compositor_frame_sink_->SubmitCompositorFrame(local_surface_id_,
-                                                std::move(frame), nullptr);
+                                                std::move(frame), nullptr, 0);
   SetNeedsBeginFrame(false);
 }
 

services/ui/ws/frame_generator_unittest.cc

diff --git a/services/ui/ws/frame_generator_unittest.cc b/services/ui/ws/frame_generator_unittest.cc
index 356d550..a3970c4 100644
--- a/services/ui/ws/frame_generator_unittest.cc
+++ b/services/ui/ws/frame_generator_unittest.cc
@@ -44,7 +44,8 @@
   void SubmitCompositorFrame(
       const viz::LocalSurfaceId& local_surface_id,
       cc::CompositorFrame frame,
-      viz::mojom::HitTestRegionListPtr hit_test_region_list) override {
+      viz::mojom::HitTestRegionListPtr hit_test_region_list,
+      uint64_t submit_time) override {
     ++frames_submitted_;
     last_frame_ = std::move(frame);
     last_begin_frame_ack_ = last_frame_.metadata.begin_frame_ack;

services/ui/ws/window_tree_client_unittest.cc

diff --git a/services/ui/ws/window_tree_client_unittest.cc b/services/ui/ws/window_tree_client_unittest.cc
index 0bc74b9..ea71a2b 100644
--- a/services/ui/ws/window_tree_client_unittest.cc
+++ b/services/ui/ws/window_tree_client_unittest.cc
@@ -2215,7 +2215,7 @@
     compositor_frame.metadata.begin_frame_ack = viz::BeginFrameAck(0, 1, true);
     viz::LocalSurfaceId local_surface_id(1, base::UnguessableToken::Create());
     surface_ptr->SubmitCompositorFrame(local_surface_id,
-                                       std::move(compositor_frame), nullptr);
+                                       std::move(compositor_frame), nullptr, 0);
   }
   // Make sure the parent connection gets the surface ID.
   wt_client1()->WaitForChangeCount(1);
@@ -2252,7 +2252,7 @@
     compositor_frame.metadata.begin_frame_ack = viz::BeginFrameAck(0, 1, true);
     viz::LocalSurfaceId local_surface_id(2, base::UnguessableToken::Create());
     surface_ptr->SubmitCompositorFrame(local_surface_id,
-                                       std::move(compositor_frame), nullptr);
+                                       std::move(compositor_frame), nullptr, 0);
   }
   // Make sure the parent connection gets the surface ID.
   wt_client2()->WaitForChangeCount(1);

services/viz/compositing/privileged/interfaces/frame_sink_manager.mojom

diff --git a/services/viz/compositing/privileged/interfaces/frame_sink_manager.mojom b/services/viz/compositing/privileged/interfaces/frame_sink_manager.mojom
index a499709..8cb3e73f 100644
--- a/services/viz/compositing/privileged/interfaces/frame_sink_manager.mojom
+++ b/services/viz/compositing/privileged/interfaces/frame_sink_manager.mojom
@@ -7,10 +7,10 @@
 import "cc/ipc/frame_sink_id.mojom";
 import "cc/ipc/local_surface_id.mojom";
 import "cc/ipc/surface_id.mojom";
-import "cc/ipc/surface_info.mojom";
 import "gpu/ipc/common/surface_handle.mojom";
 import "mojo/common/time.mojom";
 import "services/viz/public/interfaces/compositing/compositor_frame_sink.mojom";
+import "services/viz/public/interfaces/compositing/surface_info.mojom";
 import "ui/gfx/geometry/mojo/geometry.mojom";
 import "ui/gfx/mojo/color_space.mojom";
 import "services/viz/compositing/privileged/interfaces/renderer_settings.mojom";
@@ -56,7 +56,7 @@
   CreateRootCompositorFrameSink(
       cc.mojom.FrameSinkId frame_sink_id,
       gpu.mojom.SurfaceHandle widget,
-      viz.mojom.RendererSettings renderer_settings,
+      RendererSettings renderer_settings,
       associated CompositorFrameSink& compositor_frame_sink,
       CompositorFrameSinkClient compositor_frame_sink_client,
       associated DisplayPrivate& display_private);
@@ -97,7 +97,7 @@
 interface FrameSinkManagerClient {
   // Called by the frame sink manager when a CompositorFrame with a new
   // SurfaceId activates for the first time.
-  OnFirstSurfaceActivation(cc.mojom.SurfaceInfo surface_info);
+  OnFirstSurfaceActivation(SurfaceInfo surface_info);
 
   // The CompositorFrameSink pipe for |frame_sink_id| was closed. The client
   // cannot submit any CompositorFrames to viz after this occurs.

services/viz/public/cpp/compositing/compositor_frame_struct_traits.cc

diff --git a/services/viz/public/cpp/compositing/compositor_frame_struct_traits.cc b/services/viz/public/cpp/compositing/compositor_frame_struct_traits.cc
index c9bfd12..6386830 100644
--- a/services/viz/public/cpp/compositing/compositor_frame_struct_traits.cc
+++ b/services/viz/public/cpp/compositing/compositor_frame_struct_traits.cc
@@ -4,6 +4,7 @@
 
 #include "services/viz/public/cpp/compositing/compositor_frame_struct_traits.h"
 
+#include "base/trace_event/trace_event.h"
 #include "cc/ipc/compositor_frame_metadata_struct_traits.h"
 #include "cc/ipc/render_pass_struct_traits.h"
 #include "cc/ipc/transferable_resource_struct_traits.h"
@@ -13,6 +14,8 @@
 // static
 bool StructTraits<viz::mojom::CompositorFrameDataView, cc::CompositorFrame>::
     Read(viz::mojom::CompositorFrameDataView data, cc::CompositorFrame* out) {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.ipc"),
+               "StructTraits::CompositorFrame::Read");
   return data.ReadPasses(&out->render_pass_list) &&
          !out->render_pass_list.empty() && data.ReadMetadata(&out->metadata) &&
          data.ReadResources(&out->resource_list);

services/viz/public/cpp/compositing/struct_traits_unittest.cc

diff --git a/services/viz/public/cpp/compositing/struct_traits_unittest.cc b/services/viz/public/cpp/compositing/struct_traits_unittest.cc
index 9fc1046..91b56566 100644
--- a/services/viz/public/cpp/compositing/struct_traits_unittest.cc
+++ b/services/viz/public/cpp/compositing/struct_traits_unittest.cc
@@ -30,6 +30,7 @@
 #include "components/viz/common/resources/resource_settings.h"
 #include "components/viz/common/resources/returned_resource.h"
 #include "components/viz/common/resources/transferable_resource.h"
+#include "components/viz/common/surfaces/surface_info.h"
 #include "components/viz/test/begin_frame_args_test.h"
 #include "gpu/ipc/common/mailbox_holder_struct_traits.h"
 #include "gpu/ipc/common/mailbox_struct_traits.h"
@@ -40,8 +41,10 @@
 #include "services/viz/public/cpp/compositing/compositor_frame_struct_traits.h"
 #include "services/viz/public/cpp/compositing/resource_settings_struct_traits.h"
 #include "services/viz/public/cpp/compositing/returned_resource_struct_traits.h"
+#include "services/viz/public/cpp/compositing/surface_info_struct_traits.h"
 #include "services/viz/public/interfaces/compositing/compositor_frame.mojom.h"
 #include "services/viz/public/interfaces/compositing/returned_resource.mojom.h"
+#include "services/viz/public/interfaces/compositing/surface_info.mojom.h"
 #include "skia/public/interfaces/bitmap_skbitmap_struct_traits.h"
 #include "skia/public/interfaces/blur_image_filter_tile_mode_struct_traits.h"
 #include "skia/public/interfaces/image_filter_struct_traits.h"
@@ -217,6 +220,23 @@
             out_solid_color_draw_quad->force_anti_aliasing_off);
 }
 
+TEST_F(StructTraitsTest, SurfaceInfo) {
+  const SurfaceId surface_id(
+      FrameSinkId(1234, 4321),
+      LocalSurfaceId(5678,
+                     base::UnguessableToken::Deserialize(143254, 144132)));
+  constexpr float device_scale_factor = 1.234f;
+  constexpr gfx::Size size(987, 123);
+
+  const SurfaceInfo input(surface_id, device_scale_factor, size);
+  SurfaceInfo output;
+  SerializeAndDeserialize<mojom::SurfaceInfo>(input, &output);
+
+  EXPECT_EQ(input.id(), output.id());
+  EXPECT_EQ(input.size_in_pixels(), output.size_in_pixels());
+  EXPECT_EQ(input.device_scale_factor(), output.device_scale_factor());
+}
+
 TEST_F(StructTraitsTest, ReturnedResource) {
   const cc::RenderPassId id = 1337u;
   const gpu::CommandBufferNamespace command_buffer_namespace = gpu::IN_PROCESS;

services/viz/public/cpp/compositing/surface_info.typemap

diff --git a/services/viz/public/cpp/compositing/surface_info.typemap b/services/viz/public/cpp/compositing/surface_info.typemap
new file mode 100644
index 0000000..aaf163f
--- /dev/null
+++ b/services/viz/public/cpp/compositing/surface_info.typemap
@@ -0,0 +1,12 @@
+# Copyright 2017 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+mojom = "//services/viz/public/interfaces/compositing/surface_info.mojom"
+public_headers = [ "//components/viz/common/surfaces/surface_info.h" ]
+traits_headers =
+    [ "//services/viz/public/cpp/compositing/surface_info_struct_traits.h" ]
+deps = [
+  "//components/viz/common",
+]
+type_mappings = [ "viz.mojom.SurfaceInfo=viz::SurfaceInfo" ]

services/viz/public/cpp/compositing/surface_info_struct_traits.h

diff --git a/cc/ipc/surface_info_struct_traits.h b/services/viz/public/cpp/compositing/surface_info_struct_traits.h
similarity index 63%
rename from cc/ipc/surface_info_struct_traits.h
rename to services/viz/public/cpp/compositing/surface_info_struct_traits.h
index b326f392..b7ca003 100644
--- a/cc/ipc/surface_info_struct_traits.h
+++ b/services/viz/public/cpp/compositing/surface_info_struct_traits.h
@@ -2,16 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CC_IPC_SURFACE_INFO_STRUCT_TRAITS_H_
-#define CC_IPC_SURFACE_INFO_STRUCT_TRAITS_H_
+#ifndef SERVICES_VIZ_PUBLIC_CPP_COMPOSITING_SURFACE_INFO_STRUCT_TRAITS_H_
+#define SERVICES_VIZ_PUBLIC_CPP_COMPOSITING_SURFACE_INFO_STRUCT_TRAITS_H_
 
-#include "cc/ipc/surface_info.mojom-shared.h"
 #include "components/viz/common/surfaces/surface_info.h"
+#include "services/viz/public/interfaces/compositing/surface_info.mojom-shared.h"
 
 namespace mojo {
 
 template <>
-struct StructTraits<cc::mojom::SurfaceInfoDataView, viz::SurfaceInfo> {
+struct StructTraits<viz::mojom::SurfaceInfoDataView, viz::SurfaceInfo> {
   static const viz::SurfaceId& surface_id(
       const viz::SurfaceInfo& surface_info) {
     return surface_info.id();
@@ -25,7 +25,8 @@
     return surface_info.size_in_pixels();
   }
 
-  static bool Read(cc::mojom::SurfaceInfoDataView data, viz::SurfaceInfo* out) {
+  static bool Read(viz::mojom::SurfaceInfoDataView data,
+                   viz::SurfaceInfo* out) {
     out->device_scale_factor_ = data.device_scale_factor();
     return data.ReadSurfaceId(&out->id_) &&
            data.ReadSizeInPixels(&out->size_in_pixels_) && out->is_valid();
@@ -34,4 +35,4 @@
 
 }  // namespace mojo
 
-#endif  // CC_IPC_SURFACE_INFO_STRUCT_TRAITS_H_
+#endif  // SERVICES_VIZ_PUBLIC_CPP_COMPOSITING_SURFACE_INFO_STRUCT_TRAITS_H_

services/viz/public/cpp/compositing/typemaps.gni

diff --git a/services/viz/public/cpp/compositing/typemaps.gni b/services/viz/public/cpp/compositing/typemaps.gni
index c0974d95..db606faf 100644
--- a/services/viz/public/cpp/compositing/typemaps.gni
+++ b/services/viz/public/cpp/compositing/typemaps.gni
@@ -6,4 +6,5 @@
   "//services/viz/public/cpp/compositing/compositor_frame.typemap",
   "//services/viz/public/cpp/compositing/resource_settings.typemap",
   "//services/viz/public/cpp/compositing/returned_resource.typemap",
+  "//services/viz/public/cpp/compositing/surface_info.typemap",
 ]

services/viz/public/interfaces/compositing/BUILD.gn

diff --git a/services/viz/public/interfaces/compositing/BUILD.gn b/services/viz/public/interfaces/compositing/BUILD.gn
index 22d92f8c..4f10daa0 100644
--- a/services/viz/public/interfaces/compositing/BUILD.gn
+++ b/services/viz/public/interfaces/compositing/BUILD.gn
@@ -10,6 +10,7 @@
     "compositor_frame_sink.mojom",
     "resource_settings.mojom",
     "returned_resource.mojom",
+    "surface_info.mojom",
   ]
 
   public_deps = [

services/viz/public/interfaces/compositing/compositor_frame_sink.mojom

diff --git a/services/viz/public/interfaces/compositing/compositor_frame_sink.mojom b/services/viz/public/interfaces/compositing/compositor_frame_sink.mojom
index 22973aa..2951b77 100644
--- a/services/viz/public/interfaces/compositing/compositor_frame_sink.mojom
+++ b/services/viz/public/interfaces/compositing/compositor_frame_sink.mojom
@@ -29,13 +29,18 @@
   // to screen the next time frames from all CompositorFrameSinks are aggregated
   // to produce a display CompositorFrame. If a client wishes to allocate a new
   // surface (e.g. during resize), then it can simply allocate a new
-  // |local_surface_id|.
+  // |local_surface_id|. Submit time is set to when this function is called to
+  // used for tracing how much time is spend between a CompositorFrame is sent
+  // and received.
+  // TODO(weiliangc): Submit time is recorded in microseconds right now and
+  // should be changed to use TimeTicks when Blink can send base types directly.
   // For successful swaps, the implementation must call
   // DidReceiveCompositorFrameAck() asynchronously when the frame has been
   // processed in order to unthrottle the next frame.
   SubmitCompositorFrame(cc.mojom.LocalSurfaceId local_surface_id,
                         viz.mojom.CompositorFrame frame,
-                        viz.mojom.HitTestRegionList? hit_test_region_list);
+                        viz.mojom.HitTestRegionList? hit_test_region_list,
+                        uint64 submit_time);
 
   // Notifies the frame sink that a BeginFrame was completed, but that no
   // CompositorFrame was produced as a result of it.

services/viz/public/interfaces/compositing/surface_info.mojom

diff --git a/cc/ipc/surface_info.mojom b/services/viz/public/interfaces/compositing/surface_info.mojom
similarity index 89%
rename from cc/ipc/surface_info.mojom
rename to services/viz/public/interfaces/compositing/surface_info.mojom
index 490009a..2c2087c 100644
--- a/cc/ipc/surface_info.mojom
+++ b/services/viz/public/interfaces/compositing/surface_info.mojom
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-module cc.mojom;
+module viz.mojom;
 
 import "cc/ipc/surface_id.mojom";
 import "ui/gfx/geometry/mojo/geometry.mojom";
@@ -10,7 +10,7 @@
 // Holds information about an embeddable surface. This data can be passed
 // across clients to embed the associated surface in another client.
 struct SurfaceInfo {
-  SurfaceId surface_id;
+  cc.mojom.SurfaceId surface_id;
   float device_scale_factor;
   gfx.mojom.Size size_in_pixels;
 };

testing/buildbot/chromium.perf.fyi.json

diff --git a/testing/buildbot/chromium.perf.fyi.json b/testing/buildbot/chromium.perf.fyi.json
index 405aa79..06aa2fd 100644
--- a/testing/buildbot/chromium.perf.fyi.json
+++ b/testing/buildbot/chromium.perf.fyi.json
@@ -1479,7 +1479,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -1510,7 +1510,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -2850,6 +2850,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:22b1",
+              "id": "build140-b1",
+              "os": "Windows-10-10586",
+              "pool": "Chrome-perf-fyi"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:22b1",
+              "id": "build140-b1",
+              "os": "Windows-10-10586",
+              "pool": "Chrome-perf-fyi"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -3521,6 +3582,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:22b1",
+              "id": "build141-b1",
+              "os": "Windows-10-10586",
+              "pool": "Chrome-perf-fyi"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:22b1",
+              "id": "build141-b1",
+              "os": "Windows-10-10586",
+              "pool": "Chrome-perf-fyi"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -6557,7 +6679,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -6588,7 +6710,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -7907,6 +8029,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:9874",
+              "id": "build204-b4",
+              "os": "Windows-10-10586",
+              "pool": "Chrome-perf-fyi"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:9874",
+              "id": "build204-b4",
+              "os": "Windows-10-10586",
+              "pool": "Chrome-perf-fyi"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -8578,6 +8761,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:9874",
+              "id": "build205-b4",
+              "os": "Windows-10-10586",
+              "pool": "Chrome-perf-fyi"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:9874",
+              "id": "build205-b4",
+              "os": "Windows-10-10586",
+              "pool": "Chrome-perf-fyi"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",

testing/buildbot/chromium.perf.json

diff --git a/testing/buildbot/chromium.perf.json b/testing/buildbot/chromium.perf.json
index 2315989..3fc9ae9 100644
--- a/testing/buildbot/chromium.perf.json
+++ b/testing/buildbot/chromium.perf.json
@@ -2644,6 +2644,128 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build48-b1--device5",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build48-b1--device5",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build14-b1--device1",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build14-b1--device1",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -2705,6 +2827,67 @@
       },
       {
         "args": [
+          "smoothness.image_decoding_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.image_decoding_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build14-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.image_decoding_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.image_decoding_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build14-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.key_desktop_move_cases",
           "-v",
           "--upload-results",
@@ -3559,6 +3742,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build14-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build14-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -7722,6 +7966,128 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build75-b1--device5",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build75-b1--device5",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build74-b1--device1",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build74-b1--device1",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -7783,6 +8149,67 @@
       },
       {
         "args": [
+          "smoothness.image_decoding_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.image_decoding_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build74-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.image_decoding_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.image_decoding_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build74-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.key_desktop_move_cases",
           "-v",
           "--upload-results",
@@ -8637,6 +9064,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build74-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build74-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -11550,6 +12038,68 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-webview",
+          "--webview-embedder-apk=../../out/Release/apks/SystemWebViewShell.apk"
+        ],
+        "isolate_name": "telemetry_perf_webview_tests",
+        "name": "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_webview_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build166-b1--device5",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-webview",
+          "--webview-embedder-apk=../../out/Release/apks/SystemWebViewShell.apk"
+        ],
+        "isolate_name": "telemetry_perf_webview_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_webview_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build165-b1--device1",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -11581,6 +12131,37 @@
       },
       {
         "args": [
+          "smoothness.image_decoding_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-webview",
+          "--webview-embedder-apk=../../out/Release/apks/SystemWebViewShell.apk"
+        ],
+        "isolate_name": "telemetry_perf_webview_tests",
+        "name": "smoothness.image_decoding_cases",
+        "override_compile_targets": [
+          "telemetry_perf_webview_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build164-b1--device7",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.key_desktop_move_cases",
           "-v",
           "--upload-results",
@@ -12015,6 +12596,37 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-webview",
+          "--webview-embedder-apk=../../out/Release/apks/SystemWebViewShell.apk"
+        ],
+        "isolate_name": "telemetry_perf_webview_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_webview_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build165-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -15459,6 +16071,128 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build45-b1--device5",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build45-b1--device5",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build16-b1--device1",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build16-b1--device1",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -15520,6 +16254,67 @@
       },
       {
         "args": [
+          "smoothness.image_decoding_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.image_decoding_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build16-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.image_decoding_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.image_decoding_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build16-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.key_desktop_move_cases",
           "-v",
           "--upload-results",
@@ -16374,6 +17169,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build16-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build16-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -19318,6 +20174,68 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-webview",
+          "--webview-embedder-apk=../../out/Release/apks/SystemWebViewShell.apk"
+        ],
+        "isolate_name": "telemetry_perf_webview_tests",
+        "name": "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_webview_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build114-b1--device5",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-webview",
+          "--webview-embedder-apk=../../out/Release/apks/SystemWebViewShell.apk"
+        ],
+        "isolate_name": "telemetry_perf_webview_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_webview_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build113-b1--device1",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -19349,6 +20267,37 @@
       },
       {
         "args": [
+          "smoothness.image_decoding_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-webview",
+          "--webview-embedder-apk=../../out/Release/apks/SystemWebViewShell.apk"
+        ],
+        "isolate_name": "telemetry_perf_webview_tests",
+        "name": "smoothness.image_decoding_cases",
+        "override_compile_targets": [
+          "telemetry_perf_webview_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build112-b1--device7",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.key_desktop_move_cases",
           "-v",
           "--upload-results",
@@ -19783,6 +20732,37 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-webview",
+          "--webview-embedder-apk=../../out/Release/apks/SystemWebViewShell.apk"
+        ],
+        "isolate_name": "telemetry_perf_webview_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_webview_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build113-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -23227,6 +24207,128 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build49-b1--device5",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build49-b1--device5",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build10-b1--device1",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build10-b1--device1",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -23288,6 +24390,67 @@
       },
       {
         "args": [
+          "smoothness.image_decoding_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.image_decoding_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build10-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.image_decoding_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.image_decoding_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build10-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.key_desktop_move_cases",
           "-v",
           "--upload-results",
@@ -24142,6 +25305,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build10-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build10-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -28183,6 +29407,128 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build47-b1--device5",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build47-b1--device5",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build18-b1--device1",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build18-b1--device1",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -28244,6 +29590,67 @@
       },
       {
         "args": [
+          "smoothness.image_decoding_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.image_decoding_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build18-b1--device7",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.image_decoding_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.image_decoding_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build18-b1--device7",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.key_desktop_move_cases",
           "-v",
           "--upload-results",
@@ -29098,6 +30505,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=android-chromium"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build18-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "android_devices": "1",
+              "id": "build18-b1--device3",
+              "os": "Android",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -32099,7 +33567,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -32130,7 +33598,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -33491,6 +34959,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0534",
+              "id": "build152-m1",
+              "os": "Ubuntu-14.04",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0534",
+              "id": "build152-m1",
+              "os": "Ubuntu-14.04",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -34162,6 +35691,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0534",
+              "id": "build151-m1",
+              "os": "Ubuntu-14.04",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0534",
+              "id": "build151-m1",
+              "os": "Ubuntu-14.04",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -37198,7 +38788,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -37229,7 +38819,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -38569,6 +40159,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0166",
+              "id": "build106-b1",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0166",
+              "id": "build106-b1",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -39240,6 +40891,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0166",
+              "id": "build105-b1",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0166",
+              "id": "build105-b1",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -42255,7 +43967,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -42286,7 +43998,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -43626,6 +45338,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0a2e",
+              "id": "build162-m1",
+              "os": "Mac-10.12",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0a2e",
+              "id": "build162-m1",
+              "os": "Mac-10.12",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -44297,6 +46070,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0a2e",
+              "id": "build161-m1",
+              "os": "Mac-10.12",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0a2e",
+              "id": "build161-m1",
+              "os": "Mac-10.12",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -47312,7 +49146,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -47343,7 +49177,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -48683,6 +50517,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:1626",
+              "id": "build127-b1",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:1626",
+              "id": "build127-b1",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -49354,6 +51249,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:1626",
+              "id": "build126-b1",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:1626",
+              "id": "build126-b1",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -52369,7 +54325,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -52400,7 +54356,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -53719,6 +55675,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0a26",
+              "id": "build28-b1",
+              "os": "Mac-10.12",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0a26",
+              "id": "build28-b1",
+              "os": "Mac-10.12",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -54390,6 +56407,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0a26",
+              "id": "build27-b1",
+              "os": "Mac-10.12",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0a26",
+              "id": "build27-b1",
+              "os": "Mac-10.12",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -57405,7 +59483,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -57436,7 +59514,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -58776,6 +60854,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:6821",
+              "id": "build132-b1",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:6821",
+              "id": "build132-b1",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -59447,6 +61586,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:6821",
+              "id": "build131-b1",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:6821",
+              "id": "build131-b1",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -62462,7 +64662,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -62493,7 +64693,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -63833,6 +66033,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0d26",
+              "id": "build30-b4",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0d26",
+              "id": "build30-b4",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -64504,6 +66765,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0d26",
+              "id": "build7-b1",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0d26",
+              "id": "build7-b1",
+              "os": "Mac-10.11",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -67519,7 +69841,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -67550,7 +69872,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -68869,6 +71191,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:1616",
+              "id": "build180-b4",
+              "os": "Windows-10-10240",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:1616",
+              "id": "build180-b4",
+              "os": "Windows-10-10240",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -69540,6 +71923,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:1616",
+              "id": "build120-b1",
+              "os": "Windows-10-10240",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:1616",
+              "id": "build120-b1",
+              "os": "Windows-10-10240",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -72555,7 +74999,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -72586,7 +75030,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -73926,6 +76370,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0534",
+              "id": "build136-m1",
+              "os": "Windows-10-10240",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0534",
+              "id": "build136-m1",
+              "os": "Windows-10-10240",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -74597,6 +77102,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0534",
+              "id": "build135-m1",
+              "os": "Windows-10-10240",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0534",
+              "id": "build135-m1",
+              "os": "Windows-10-10240",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -77654,7 +80220,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -77685,7 +80251,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -79046,6 +81612,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:6613",
+              "id": "build105-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:6613",
+              "id": "build105-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -79717,6 +82344,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:6613",
+              "id": "build104-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:6613",
+              "id": "build104-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -82774,7 +85462,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -82805,7 +85493,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -84145,6 +86833,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:041a",
+              "id": "build168-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:041a",
+              "id": "build168-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -84816,6 +87565,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:041a",
+              "id": "build167-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:041a",
+              "id": "build167-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -87873,7 +90683,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -87904,7 +90714,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -89244,6 +92054,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "10de:104a",
+              "id": "build96-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "10de:104a",
+              "id": "build96-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -89915,6 +92786,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "10de:104a",
+              "id": "build95-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "10de:104a",
+              "id": "build95-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -92951,7 +95883,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -92982,7 +95914,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -94322,6 +97254,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0532",
+              "id": "build189-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0532",
+              "id": "build189-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -94993,6 +97986,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0532",
+              "id": "build188-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0532",
+              "id": "build188-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -98029,7 +101083,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -98060,7 +101114,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -99400,6 +102454,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0532",
+              "id": "build142-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0532",
+              "id": "build142-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -100071,6 +103186,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0532",
+              "id": "build141-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0532",
+              "id": "build141-m1",
+              "os": "Windows-2008ServerR2-SP1",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",
@@ -103107,7 +106283,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": false,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -103138,7 +106314,7 @@
             }
           ],
           "expiration": 72000,
-          "hard_timeout": 10800,
+          "hard_timeout": 14400,
           "ignore_task_failure": true,
           "io_timeout": 3600,
           "upload_test_results": false
@@ -104499,6 +107675,67 @@
       },
       {
         "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0532",
+              "id": "build147-m1",
+              "os": "Windows-2012ServerR2-SP0",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.gpu_rasterization.tough_scrolling_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.gpu_rasterization.tough_scrolling_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0532",
+              "id": "build147-m1",
+              "os": "Windows-2012ServerR2-SP0",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.gpu_rasterization_and_decoding.image_decoding_cases",
           "-v",
           "--upload-results",
@@ -105170,6 +108407,67 @@
       },
       {
         "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=release_x64"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0532",
+              "id": "build146-m1",
+              "os": "Windows-2012ServerR2-SP0",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": false,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
+          "smoothness.tough_pinch_zoom_cases",
+          "-v",
+          "--upload-results",
+          "--output-format=chartjson",
+          "--browser=reference",
+          "--output-trace-tag=_ref"
+        ],
+        "isolate_name": "telemetry_perf_tests",
+        "name": "smoothness.tough_pinch_zoom_cases.reference",
+        "override_compile_targets": [
+          "telemetry_perf_tests"
+        ],
+        "swarming": {
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "102b:0532",
+              "id": "build146-m1",
+              "os": "Windows-2012ServerR2-SP0",
+              "pool": "Chrome-perf"
+            }
+          ],
+          "expiration": 72000,
+          "hard_timeout": 10800,
+          "ignore_task_failure": true,
+          "io_timeout": 3600,
+          "upload_test_results": false
+        }
+      },
+      {
+        "args": [
           "smoothness.tough_scrolling_cases",
           "-v",
           "--upload-results",

testing/buildbot/filters/mojo.fyi.browser_tests.filter

diff --git a/testing/buildbot/filters/mojo.fyi.browser_tests.filter b/testing/buildbot/filters/mojo.fyi.browser_tests.filter
index 0141691..d9735993 100644
--- a/testing/buildbot/filters/mojo.fyi.browser_tests.filter
+++ b/testing/buildbot/filters/mojo.fyi.browser_tests.filter
@@ -47,7 +47,6 @@
 FormAutocompleteTest.AjaxSucceeded_NoLongerVisible
 FormAutocompleteTest.AjaxSucceeded_NoLongerVisible_DifferentActionsSameData
 FormAutocompleteTest.AjaxSucceeded_NoLongerVisible_NoAction
-FormAutocompleteTest.AjaxSucceeded_StillVisible
 FormAutocompleteTest.AutoCompleteOffFormSubmit
 FormAutocompleteTest.AutoCompleteOffInputSubmit
 FormAutocompleteTest.CollectFormlessElements

testing/buildbot/filters/mojo.fyi.network_content_browsertests.filter

diff --git a/testing/buildbot/filters/mojo.fyi.network_content_browsertests.filter b/testing/buildbot/filters/mojo.fyi.network_content_browsertests.filter
index 2a81cd7..b03eeb6a 100644
--- a/testing/buildbot/filters/mojo.fyi.network_content_browsertests.filter
+++ b/testing/buildbot/filters/mojo.fyi.network_content_browsertests.filter
@@ -157,3 +157,7 @@
 -WorkerTest.SharedWorkerHttpAuth
 -WorkerTest.WorkerHttpAuth
 -WorkerTest.WorkerTlsClientAuth
+
+# content/network/url_loader_impl.cc should handle failure in
+# URLLoaderImpl::OnResponseBodyStreamRead().
+-SRC_ClearKey/EncryptedMediaTest.FrameSizeChangeVideo/0

testing/variations/fieldtrial_testing_config.json

diff --git a/testing/variations/fieldtrial_testing_config.json b/testing/variations/fieldtrial_testing_config.json
index 486d9f8..1fccfc62 100644
--- a/testing/variations/fieldtrial_testing_config.json
+++ b/testing/variations/fieldtrial_testing_config.json
@@ -1314,6 +1314,21 @@
             ]
         }
     ],
+    "MacV2Sandbox": [
+        {
+            "platforms": [
+                "mac"
+            ],
+            "experiments": [
+                {
+                    "name": "Enabled",
+                    "enable_features": [
+                        "MacV2Sandbox"
+                    ]
+                }
+            ]
+        }
+    ],
     "MaxDelayableRequestsNetworkOverride": [
         {
             "platforms": [
@@ -1730,6 +1745,29 @@
             ]
         }
     ],
+    "NonDelayableThrottlesDelayable": [
+        {
+            "platforms": [
+                "android",
+                "chromeos",
+                "linux",
+                "mac",
+                "win"
+            ],
+            "experiments": [
+                {
+                    "name": "NonDelayableWeight2",
+                    "params": {
+                        "MaxEffectiveConnectionType": "3G",
+                        "NonDelayableWeight": "2.0"
+                    },
+                    "enable_features": [
+                        "NonDelayableThrottlesDelayable"
+                    ]
+                }
+            ]
+        }
+    ],
     "OffMainThreadFetch": [
         {
             "platforms": [

third_party/WebKit/LayoutTests/FlagExpectations/enable-features=NetworkService

diff --git a/third_party/WebKit/LayoutTests/FlagExpectations/enable-features=NetworkService b/third_party/WebKit/LayoutTests/FlagExpectations/enable-features=NetworkService
index 4b08a86..77b35744 100644
--- a/third_party/WebKit/LayoutTests/FlagExpectations/enable-features=NetworkService
+++ b/third_party/WebKit/LayoutTests/FlagExpectations/enable-features=NetworkService
@@ -387,6 +387,8 @@
 Bug(none) http/tests/appcache/local-content.html [ Timeout ]
 Bug(none) http/tests/appcache/main-resource-hash.html [ Timeout ]
 Bug(none) http/tests/appcache/main-resource-redirect.html [ Timeout ]
+Bug(715632) http/tests/appcache/manifest-redirect-2.html [ Crash ]
+Bug(715632) http/tests/appcache/manifest-redirect.html [ Crash ]
 Bug(none) http/tests/appcache/manifest-parsing.html [ Failure ]
 Bug(none) http/tests/appcache/multi-fallback.html [ Failure Timeout ]
 Bug(none) http/tests/appcache/non-html.xhtml [ Timeout ]
@@ -395,6 +397,8 @@
 Bug(none) http/tests/appcache/online-whitelist.html [ Failure ]
 Bug(none) http/tests/appcache/reload.html [ Crash Failure Timeout ]
 Bug(none) http/tests/appcache/remove-cache.html [ Crash Failure Timeout ]
+Bug(715632) http/tests/appcache/resource-redirect.html [ Crash ]
+Bug(715632) http/tests/appcache/resource-redirect-2.html [ Crash ]
 Bug(none) http/tests/appcache/simple.html [ Timeout ]
 Bug(none) http/tests/appcache/top-frame-1.html [ Timeout ]
 Bug(none) http/tests/appcache/top-frame-2.html [ Crash Timeout ]

third_party/WebKit/LayoutTests/FlagExpectations/enable-slimming-paint-v2

diff --git a/third_party/WebKit/LayoutTests/FlagExpectations/enable-slimming-paint-v2 b/third_party/WebKit/LayoutTests/FlagExpectations/enable-slimming-paint-v2
index a616b96..59648a3 100644
--- a/third_party/WebKit/LayoutTests/FlagExpectations/enable-slimming-paint-v2
+++ b/third_party/WebKit/LayoutTests/FlagExpectations/enable-slimming-paint-v2
@@ -1767,6 +1767,22 @@
 Bug(none) fast/layers/opacity-stacking.html [ Failure ]
 Bug(none) paint/invalidation/column-float-under-stacked-inline.html [ Failure ]
 
+# ScrollHitTest display items cause extra, incorrect, invalidations.
+crbug.com/738613 paint/invalidation/destroy-overlay-scrollbar.html [ Failure ]
+crbug.com/738613 paint/invalidation/destroy-scrollbar.html [ Failure ]
+crbug.com/738613 paint/invalidation/overflow-auto-in-overflow-auto-scrolled.html [ Failure ]
+crbug.com/738613 paint/invalidation/overflow-scroll-composited-non-stacking-child.html [ Failure ]
+crbug.com/738613 paint/invalidation/overflow-scroll-in-overflow-scroll-scrolled.html [ Failure ]
+crbug.com/738613 paint/invalidation/resize-iframe-text.html [ Failure ]
+crbug.com/738613 paint/invalidation/resize-scrollable-iframe.html [ Failure ]
+crbug.com/738613 paint/invalidation/scroll-inside-table-cell.html [ Failure ]
+crbug.com/738613 paint/invalidation/scroll-relative-table-inside-table-cell.html [ Failure ]
+crbug.com/738613 paint/invalidation/svg/nested-embedded-svg-size-changes-no-layout-triggers-1.html [ Failure ]
+crbug.com/738613 paint/invalidation/svg/nested-embedded-svg-size-changes-no-layout-triggers-2.html [ Failure ]
+crbug.com/738613 paint/invalidation/table-overflow-auto-in-overflow-auto-scrolled.html [ Failure ]
+crbug.com/738613 paint/invalidation/table-overflow-scroll-in-overflow-scroll-scrolled.html [ Failure ]
+crbug.com/738613 paint/invalidation/textarea-caret.html [ Failure ]
+
 # See comment regarding this test in NeverFixTests. It also fails for other
 # reasons, in particular that the composited layerization algorithm provides
 # different results.

third_party/WebKit/LayoutTests/TestExpectations

diff --git a/third_party/WebKit/LayoutTests/TestExpectations b/third_party/WebKit/LayoutTests/TestExpectations
index 22404cef..682a13e 100644
--- a/third_party/WebKit/LayoutTests/TestExpectations
+++ b/third_party/WebKit/LayoutTests/TestExpectations
@@ -124,11 +124,6 @@
 crbug.com/739559 virtual/gpu-rasterization/images/cross-fade-overflow-position.html [ Failure Pass ]
 crbug.com/739559 virtual/gpu-rasterization/images/cross-fade-tiled.html [ Failure Pass ]
 
-crbug.com/746578 fast/css/transformed-mask.html [ NeedsManualRebaseline ]
-crbug.com/746578 fast/reflections/reflection-masks-opacity.html [ NeedsManualRebaseline ]
-crbug.com/746578 fast/reflections/reflection-masks.html [ NeedsManualRebaseline ]
-crbug.com/746578 svg/filters/feImage-preserveAspectratio.svg [ NeedsManualRebaseline ]
-
 crbug.com/747502 paint/roundedrects/input-with-rounded-rect-and-shadow.html [ NeedsManualRebaseline ]
 crbug.com/747502 fast/borders/border-radius-with-box-shadow.html [ NeedsManualRebaseline ]
 crbug.com/747502 paint/roundedrects/circle-with-shadow.html [ NeedsManualRebaseline ]

third_party/WebKit/LayoutTests/external/WPT_BASE_MANIFEST.json

diff --git a/third_party/WebKit/LayoutTests/external/WPT_BASE_MANIFEST.json b/third_party/WebKit/LayoutTests/external/WPT_BASE_MANIFEST.json
index ea475f0..575af39a 100644
--- a/third_party/WebKit/LayoutTests/external/WPT_BASE_MANIFEST.json
+++ b/third_party/WebKit/LayoutTests/external/WPT_BASE_MANIFEST.json
@@ -99468,11 +99468,6 @@
      {}
     ]
    ],
-   "html/semantics/text-level-semantics/the-time-element/001-expected.txt": [
-    [
-     {}
-    ]
-   ],
    "html/semantics/text-level-semantics/the-u-element/.gitkeep": [
     [
      {}
@@ -139035,6 +139030,18 @@
      {}
     ]
    ],
+   "html/semantics/selectors/pseudo-classes/placeholder-shown-type-change.html": [
+    [
+     "/html/semantics/selectors/pseudo-classes/placeholder-shown-type-change.html",
+     {}
+    ]
+   ],
+   "html/semantics/selectors/pseudo-classes/readwrite-readonly-type-change.html": [
+    [
+     "/html/semantics/selectors/pseudo-classes/readwrite-readonly-type-change.html",
+     {}
+    ]
+   ],
    "html/semantics/selectors/pseudo-classes/readwrite-readonly.html": [
     [
      "/html/semantics/selectors/pseudo-classes/readwrite-readonly.html",
@@ -183091,11 +183098,11 @@
    "support"
   ],
   "background-fetch/interfaces-expected.txt": [
-   "19fa33f3051ab724d8d6bf3439feb459cfaec9ec",
+   "aa898874db8a0e7d1996e5c6edf908e630ad59f1",
    "support"
   ],
   "background-fetch/interfaces-worker.https-expected.txt": [
-   "d5017ead5f32888979f3cf44ed1181c70b6b3158",
+   "d71d5e37ff9207c0f649048605c608ea4bdf381d",
    "support"
   ],
   "background-fetch/interfaces-worker.https.html": [
@@ -183107,11 +183114,11 @@
    "testharness"
   ],
   "background-fetch/interfaces.idl": [
-   "cb1f28998d888157cfde900072ab8220f9709837",
+   "fce19c6d658a1bae8c79ab659da9a9201a7b02bb",
    "support"
   ],
   "background-fetch/interfaces.worker-expected.txt": [
-   "60267f1d9570bef5c98ccb4dd049397a5d1083b9",
+   "460a2a19f8dffd1763bb3053f62e26b9374becf5",
    "support"
   ],
   "background-fetch/interfaces.worker.js": [
@@ -224607,7 +224614,7 @@
    "testharness"
   ],
   "dom/nodes/Element-classlist.html": [
-   "4ff46caa5ddf71a0b91ddf921882114d0c89d9d3",
+   "10a0336430514dbbe8e837472c4476254ea8f8fc",
    "testharness"
   ],
   "dom/nodes/Element-closest-expected.txt": [
@@ -224819,7 +224826,7 @@
    "testharness"
   ],
   "dom/nodes/Node-cloneNode-expected.txt": [
-   "5bcb7f3ecd94153fb98772046c60be2ad4b64477",
+   "ae2b6de915cea4a0a83fc5fbcb64c76842deb771",
    "support"
   ],
   "dom/nodes/Node-cloneNode.html": [
@@ -233895,7 +233902,7 @@
    "support"
   ],
   "html/dom/interfaces-expected.txt": [
-   "cf6987352fec2afd2f500e587ef19c355a9333e3",
+   "0e0f256e79bf4c71a581dae5071fe1c916c3fa74",
    "support"
   ],
   "html/dom/interfaces.html": [
@@ -233979,7 +233986,7 @@
    "testharness"
   ],
   "html/dom/reflection-text-expected.txt": [
-   "9780eea7885988ed81e230b04e317ea2ea1e64d1",
+   "f835c3835acac766932629290574f2146562c4bf",
    "support"
   ],
   "html/dom/reflection-text.html": [
@@ -241827,7 +241834,7 @@
    "testharness"
   ],
   "html/semantics/interfaces-expected.txt": [
-   "7643ae2bdd9f47e34a2e012af0b3b92730347927",
+   "2fd7b15b1041a31ca83df44f9da54310c5c00468",
    "support"
   ],
   "html/semantics/interfaces.html": [
@@ -243086,16 +243093,24 @@
    "c35cbd27d802f058e34ef687e41e3bb0f5a1ec3b",
    "testharness"
   ],
+  "html/semantics/selectors/pseudo-classes/placeholder-shown-type-change.html": [
+   "d3d596673f9a9310d433f3500109ec03e1b7e588",
+   "testharness"
+  ],
   "html/semantics/selectors/pseudo-classes/readwrite-readonly-expected.txt": [
    "f8d75cdabe9e2520735cf56476def3ce49500b7f",
    "support"
   ],
+  "html/semantics/selectors/pseudo-classes/readwrite-readonly-type-change.html": [
+   "68bfceb6c65638a0deeba8630c2e6e09f5dc344c",
+   "testharness"
+  ],
   "html/semantics/selectors/pseudo-classes/readwrite-readonly.html": [
    "835c87fe2a1952890b1adc3f39981a0c1360b5be",
    "testharness"
   ],
   "html/semantics/selectors/pseudo-classes/required-optional-hidden.html": [
-   "f46d516f68e83556f4f7575521df65aa384961b4",
+   "0d132ded36e5eaad8c5a4018bc6f966c739f70ca",
    "testharness"
   ],
   "html/semantics/selectors/pseudo-classes/required-optional.html": [
@@ -243598,10 +243613,6 @@
    "da39a3ee5e6b4b0d3255bfef95601890afd80709",
    "support"
   ],
-  "html/semantics/text-level-semantics/the-time-element/001-expected.txt": [
-   "ea78e99d93725ea4bfa2a9d7edfec2035d63dba9",
-   "support"
-  ],
   "html/semantics/text-level-semantics/the-time-element/001.html": [
    "437568c95f09bac529d5625a66f41d4c57b0eece",
    "testharness"

third_party/WebKit/LayoutTests/external/wpt/dom/nodes/Element-classlist.html

diff --git a/third_party/WebKit/LayoutTests/external/wpt/dom/nodes/Element-classlist.html b/third_party/WebKit/LayoutTests/external/wpt/dom/nodes/Element-classlist.html
index 1c8ba2d..bc28b1c 100644
--- a/third_party/WebKit/LayoutTests/external/wpt/dom/nodes/Element-classlist.html
+++ b/third_party/WebKit/LayoutTests/external/wpt/dom/nodes/Element-classlist.html
@@ -416,9 +416,6 @@
   checkReplace(" ", "a", "b", " ");
   checkReplace(" a  \f", "a", "b", "b");
   checkReplace("a b c", "b", "d", "a d c");
-  // https://github.com/whatwg/dom/issues/442
-  // Implementations agree on the first one here, so I test it, but disagree on
-  // the second, so no test until the spec decides what to say.
   checkReplace("a b c", "c", "a", "a b");
   checkReplace("c b a", "c", "a", "a b");
   checkReplace("a b a", "a", "c", "c b");

third_party/WebKit/LayoutTests/fast/reflections/reflection-masks-expected.png

diff --git a/third_party/WebKit/LayoutTests/fast/reflections/reflection-masks-expected.png b/third_party/WebKit/LayoutTests/fast/reflections/reflection-masks-expected.png
index b1233438..5b79bc01 100644
--- a/third_party/WebKit/LayoutTests/fast/reflections/reflection-masks-expected.png
+++ b/third_party/WebKit/LayoutTests/fast/reflections/reflection-masks-expected.png
Binary files differ

third_party/WebKit/LayoutTests/fast/reflections/reflection-masks-opacity-expected.png

diff --git a/third_party/WebKit/LayoutTests/fast/reflections/reflection-masks-opacity-expected.png b/third_party/WebKit/LayoutTests/fast/reflections/reflection-masks-opacity-expected.png
index 58ca0f2..84acb46 100644
--- a/third_party/WebKit/LayoutTests/fast/reflections/reflection-masks-opacity-expected.png
+++ b/third_party/WebKit/LayoutTests/fast/reflections/reflection-masks-opacity-expected.png
Binary files differ

third_party/WebKit/LayoutTests/http/tests/inspector/debugger-test.js

diff --git a/third_party/WebKit/LayoutTests/http/tests/inspector/debugger-test.js b/third_party/WebKit/LayoutTests/http/tests/inspector/debugger-test.js
index 6b63c081..7542c935 100644
--- a/third_party/WebKit/LayoutTests/http/tests/inspector/debugger-test.js
+++ b/third_party/WebKit/LayoutTests/http/tests/inspector/debugger-test.js
@@ -644,7 +644,7 @@
 
 InspectorTest.evaluateOnCurrentCallFrame = function(code)
 {
-    return new Promise(succ => InspectorTest.debuggerModel.evaluateOnSelectedCallFrame(code, "console", false, true, false, false, InspectorTest.safeWrap(succ)));
+    return InspectorTest.debuggerModel.evaluateOnSelectedCallFrame({expression: code, objectGroup: "console"});
 }
 
 InspectorTest.waitJavaScriptSourceFrameBreakpoints = function(sourceFrame, inline)

third_party/WebKit/LayoutTests/http/tests/inspector/inspector-test.js

diff --git a/third_party/WebKit/LayoutTests/http/tests/inspector/inspector-test.js b/third_party/WebKit/LayoutTests/http/tests/inspector/inspector-test.js
index 2078228d..44a51977 100644
--- a/third_party/WebKit/LayoutTests/http/tests/inspector/inspector-test.js
+++ b/third_party/WebKit/LayoutTests/http/tests/inspector/inspector-test.js
@@ -116,12 +116,7 @@
 {
     var expression = "testRunner.evaluateInWebInspectorOverlay(\"(\" + " + func + " + \")()\")";
     var mainContext = InspectorTest.runtimeModel.executionContexts()[0];
-    mainContext.evaluate(expression, "", false, false, true, false, false, wrapCallback);
-
-    function wrapCallback(result, exceptionDetails)
-    {
-        callback(result.value)
-    }
+    mainContext.evaluate({expression: expression, returnByValue:true}).then(result => callback(result.object.value));
 }
 
 InspectorTest.check = function(passCondition, failureText)

third_party/WebKit/LayoutTests/http/tests/inspector/network/network-initiator-from-console.html

diff --git a/third_party/WebKit/LayoutTests/http/tests/inspector/network/network-initiator-from-console.html b/third_party/WebKit/LayoutTests/http/tests/inspector/network/network-initiator-from-console.html
index 5c8c04d..d78994a 100644
--- a/third_party/WebKit/LayoutTests/http/tests/inspector/network/network-initiator-from-console.html
+++ b/third_party/WebKit/LayoutTests/http/tests/inspector/network/network-initiator-from-console.html
@@ -14,7 +14,7 @@
         str += "var s = document.createElement(\"script\");";
         str += "s.src = \"resources/silent_script.js\";";
         str += "document.head.appendChild(s);";
-        UI.context.flavor(SDK.ExecutionContext).evaluate(str, "console", true, undefined, undefined, undefined, undefined, function(){});
+        UI.context.flavor(SDK.ExecutionContext).evaluate({expression: str, objectGroup: "console"});
     }
 
     function onRequest(event)

third_party/WebKit/LayoutTests/inspector/console/console-save-to-temp-var.html

diff --git a/third_party/WebKit/LayoutTests/inspector/console/console-save-to-temp-var.html b/third_party/WebKit/LayoutTests/inspector/console/console-save-to-temp-var.html
index e057e8c..2e3801d 100644
--- a/third_party/WebKit/LayoutTests/inspector/console/console-save-to-temp-var.html
+++ b/third_party/WebKit/LayoutTests/inspector/console/console-save-to-temp-var.html
@@ -40,14 +40,14 @@
             return;
         }
 
-        function didEvaluate(result, exceptionDetails)
+        function didEvaluate(result)
         {
-            InspectorTest.assertTrue(!exceptionDetails, "FAIL: was thrown. Expression: " + expression);
-            UI.panels.sources._saveToTempVariable(result);
+            InspectorTest.assertTrue(!result.exceptionDetails, "FAIL: was thrown. Expression: " + expression);
+            UI.panels.sources._saveToTempVariable(result.object);
             InspectorTest.waitUntilNthMessageReceived(2, evaluateNext);
         }
 
-        UI.context.flavor(SDK.ExecutionContext).evaluate(expression, "console", true, undefined, undefined, undefined, undefined, didEvaluate);
+        UI.context.flavor(SDK.ExecutionContext).evaluate({expression: expression, objectGroup:"console"}).then(didEvaluate);
     }
 
     function dumpConsoleMessages()

third_party/WebKit/LayoutTests/inspector/sources/debugger-ui/debugger-save-to-temp-var.html

diff --git a/third_party/WebKit/LayoutTests/inspector/sources/debugger-ui/debugger-save-to-temp-var.html b/third_party/WebKit/LayoutTests/inspector/sources/debugger-ui/debugger-save-to-temp-var.html
index 4ae99322..44e24662 100644
--- a/third_party/WebKit/LayoutTests/inspector/sources/debugger-ui/debugger-save-to-temp-var.html
+++ b/third_party/WebKit/LayoutTests/inspector/sources/debugger-ui/debugger-save-to-temp-var.html
@@ -81,14 +81,14 @@
             return;
         }
 
-        function didEvaluate(result, exceptionDetails)
+        function didEvaluate(result)
         {
-            InspectorTest.assertTrue(!exceptionDetails, "FAIL: was thrown. Expression: " + expression);
-            UI.panels.sources._saveToTempVariable(result);
+            InspectorTest.assertTrue(!result.exceptionDetails, "FAIL: was thrown. Expression: " + expression);
+            UI.panels.sources._saveToTempVariable(result.object);
             InspectorTest.waitUntilNthMessageReceived(2, evaluateNext);
         }
 
-        UI.context.flavor(SDK.ExecutionContext).evaluate(expression, "console", true, undefined, undefined, undefined, undefined, didEvaluate);
+        UI.context.flavor(SDK.ExecutionContext).evaluate({expression: expression, objectGroup: "console"}).then(didEvaluate);
     }
 
     function tearDown()

third_party/WebKit/LayoutTests/inspector/sources/debugger-ui/show-function-definition.html

diff --git a/third_party/WebKit/LayoutTests/inspector/sources/debugger-ui/show-function-definition.html b/third_party/WebKit/LayoutTests/inspector/sources/debugger-ui/show-function-definition.html
index fd0645c..227f32bd 100644
--- a/third_party/WebKit/LayoutTests/inspector/sources/debugger-ui/show-function-definition.html
+++ b/third_party/WebKit/LayoutTests/inspector/sources/debugger-ui/show-function-definition.html
@@ -18,13 +18,13 @@
         function testRevealFunctionDefinition(next)
         {
             InspectorTest.addSniffer(panel, "showUISourceCode", showUISourceCodeHook);
-            UI.context.flavor(SDK.ExecutionContext).evaluate("jumpToMe", "", false, true, false, false, false, didGetFunction);
+            UI.context.flavor(SDK.ExecutionContext).evaluate({expression: "jumpToMe", silent:true}).then(didGetFunction);
 
-            function didGetFunction(funcObject, exceptionDetails)
+            function didGetFunction(result)
             {
-                var error = !funcObject || !!exceptionDetails;
+                var error = !result.object || !!result.exceptionDetails;
                 InspectorTest.assertTrue(!error);
-                panel._showFunctionDefinition(funcObject);
+                panel._showFunctionDefinition(result.object);
             }
 
             function showUISourceCodeHook(uiSourceCode, lineNumber, columnNumber, forceShowInPanel)

third_party/WebKit/LayoutTests/inspector/sources/debugger/debugger-minified-variables-evalution.html

diff --git a/third_party/WebKit/LayoutTests/inspector/sources/debugger/debugger-minified-variables-evalution.html b/third_party/WebKit/LayoutTests/inspector/sources/debugger/debugger-minified-variables-evalution.html
index 4ffe8a1..7d0cc9d2 100644
--- a/third_party/WebKit/LayoutTests/inspector/sources/debugger/debugger-minified-variables-evalution.html
+++ b/third_party/WebKit/LayoutTests/inspector/sources/debugger/debugger-minified-variables-evalution.html
@@ -4,9 +4,9 @@
 <script src="../../../http/tests/inspector/debugger-test.js"></script>
 <script src="resources/resolve-expressions-compressed.js"></script>
 <script>
+
 function test()
 {
-    Runtime.experiments.enableForTest("resolveVariableNames");
     InspectorTest.startDebuggerTest(step1);
 
     function step1()
@@ -46,7 +46,7 @@
     {
         return Sources.SourceMapNamesResolver.resolveExpression(UI.context.flavor(SDK.DebuggerModel.CallFrame), position.originText, uiSourceCode, position.line, position.startColumn, position.endColumn)
             .then(InspectorTest.evaluateOnCurrentCallFrame)
-            .then(remoteObject => InspectorTest.addResult(remoteObject.description));
+            .then(result => InspectorTest.addResult(result.object.description));
     }
 }
 

third_party/WebKit/LayoutTests/platform/linux/fast/css/transformed-mask-expected.png

diff --git a/third_party/WebKit/LayoutTests/platform/linux/fast/css/transformed-mask-expected.png b/third_party/WebKit/LayoutTests/platform/linux/fast/css/transformed-mask-expected.png
index d60c7d8..cf3831d 100644
--- a/third_party/WebKit/LayoutTests/platform/linux/fast/css/transformed-mask-expected.png
+++ b/third_party/WebKit/LayoutTests/platform/linux/fast/css/transformed-mask-expected.png
Binary files differ

third_party/WebKit/LayoutTests/platform/mac/fast/css/transformed-mask-expected.png

diff --git a/third_party/WebKit/LayoutTests/platform/mac/fast/css/transformed-mask-expected.png b/third_party/WebKit/LayoutTests/platform/mac/fast/css/transformed-mask-expected.png
index e026152f..f4f175d 100644
--- a/third_party/WebKit/LayoutTests/platform/mac/fast/css/transformed-mask-expected.png
+++ b/third_party/WebKit/LayoutTests/platform/mac/fast/css/transformed-mask-expected.png
Binary files differ

third_party/WebKit/LayoutTests/platform/win/fast/css/transformed-mask-expected.png

diff --git a/third_party/WebKit/LayoutTests/platform/win/fast/css/transformed-mask-expected.png b/third_party/WebKit/LayoutTests/platform/win/fast/css/transformed-mask-expected.png
index 0055650e..4d902fa 100644
--- a/third_party/WebKit/LayoutTests/platform/win/fast/css/transformed-mask-expected.png
+++ b/third_party/WebKit/LayoutTests/platform/win/fast/css/transformed-mask-expected.png
Binary files differ

third_party/WebKit/LayoutTests/svg/filters/feImage-preserveAspectratio-expected.png

diff --git a/third_party/WebKit/LayoutTests/svg/filters/feImage-preserveAspectratio-expected.png b/third_party/WebKit/LayoutTests/svg/filters/feImage-preserveAspectratio-expected.png
index 414e4f6..3d0de88b 100644
--- a/third_party/WebKit/LayoutTests/svg/filters/feImage-preserveAspectratio-expected.png
+++ b/third_party/WebKit/LayoutTests/svg/filters/feImage-preserveAspectratio-expected.png
Binary files differ

third_party/WebKit/LayoutTests/vr/resources/mock-vr-service.js

diff --git a/third_party/WebKit/LayoutTests/vr/resources/mock-vr-service.js b/third_party/WebKit/LayoutTests/vr/resources/mock-vr-service.js
index f514009..b6682a8 100644
--- a/third_party/WebKit/LayoutTests/vr/resources/mock-vr-service.js
+++ b/third_party/WebKit/LayoutTests/vr/resources/mock-vr-service.js
@@ -13,7 +13,7 @@
     }
   }
 
-  requestPresent(secureOrigin, submitFrameClient, request) {
+  requestPresent(submitFrameClient, request) {
     this.presentation_provider_.bind(submitFrameClient, request);
     return Promise.resolve({success: true});
   }

third_party/WebKit/Source/core/editing/BUILD.gn

diff --git a/third_party/WebKit/Source/core/editing/BUILD.gn b/third_party/WebKit/Source/core/editing/BUILD.gn
index 835d7ab..2a374b6 100644
--- a/third_party/WebKit/Source/core/editing/BUILD.gn
+++ b/third_party/WebKit/Source/core/editing/BUILD.gn
@@ -236,6 +236,10 @@
     "markers/SpellingMarkerListImpl.h",
     "markers/StyleableMarker.cpp",
     "markers/StyleableMarker.h",
+    "markers/SuggestionMarker.cpp",
+    "markers/SuggestionMarker.h",
+    "markers/SuggestionMarkerListImpl.cpp",
+    "markers/SuggestionMarkerListImpl.h",
     "markers/TextMatchMarker.cpp",
     "markers/TextMatchMarker.h",
     "markers/TextMatchMarkerListImpl.cpp",
@@ -358,6 +362,8 @@
     "markers/GrammarMarkerTest.cpp",
     "markers/SpellingMarkerListImplTest.cpp",
     "markers/SpellingMarkerTest.cpp",
+    "markers/SuggestionMarkerListImplTest.cpp",
+    "markers/SuggestionMarkerTest.cpp",
     "markers/TextMatchMarkerListImplTest.cpp",
     "serializers/StyledMarkupSerializerTest.cpp",
     "spellcheck/IdleSpellCheckCallbackTest.cpp",

third_party/WebKit/Source/core/editing/markers/DocumentMarker.h

diff --git a/third_party/WebKit/Source/core/editing/markers/DocumentMarker.h b/third_party/WebKit/Source/core/editing/markers/DocumentMarker.h
index ba638a4..342fffd 100644
--- a/third_party/WebKit/Source/core/editing/markers/DocumentMarker.h
+++ b/third_party/WebKit/Source/core/editing/markers/DocumentMarker.h
@@ -44,6 +44,7 @@
     kTextMatchMarkerIndex,
     kCompositionMarkerIndex,
     kActiveSuggestionMarkerIndex,
+    kSuggestionMarkerIndex,
     kMarkerTypeIndexesCount
   };
 
@@ -53,6 +54,7 @@
     kTextMatch = 1 << kTextMatchMarkerIndex,
     kComposition = 1 << kCompositionMarkerIndex,
     kActiveSuggestion = 1 << kActiveSuggestionMarkerIndex,
+    kSuggestion = 1 << kSuggestionMarkerIndex,
   };
 
   class MarkerTypesIterator

third_party/WebKit/Source/core/editing/markers/DocumentMarkerController.cpp

diff --git a/third_party/WebKit/Source/core/editing/markers/DocumentMarkerController.cpp b/third_party/WebKit/Source/core/editing/markers/DocumentMarkerController.cpp
index ab1dfbf..97bc652 100644
--- a/third_party/WebKit/Source/core/editing/markers/DocumentMarkerController.cpp
+++ b/third_party/WebKit/Source/core/editing/markers/DocumentMarkerController.cpp
@@ -43,6 +43,8 @@
 #include "core/editing/markers/GrammarMarkerListImpl.h"
 #include "core/editing/markers/SpellingMarker.h"
 #include "core/editing/markers/SpellingMarkerListImpl.h"
+#include "core/editing/markers/SuggestionMarker.h"
+#include "core/editing/markers/SuggestionMarkerListImpl.h"
 #include "core/editing/markers/TextMatchMarker.h"
 #include "core/editing/markers/TextMatchMarkerListImpl.h"
 #include "core/frame/LocalFrameView.h"
@@ -69,6 +71,8 @@
       return DocumentMarker::kCompositionMarkerIndex;
     case DocumentMarker::kActiveSuggestion:
       return DocumentMarker::kActiveSuggestionMarkerIndex;
+    case DocumentMarker::kSuggestion:
+      return DocumentMarker::kSuggestionMarkerIndex;
   }
 
   NOTREACHED();
@@ -85,6 +89,8 @@
       return new SpellingMarkerListImpl();
     case DocumentMarker::kGrammar:
       return new GrammarMarkerListImpl();
+    case DocumentMarker::kSuggestion:
+      return new SuggestionMarkerListImpl();
     case DocumentMarker::kTextMatch:
       return new TextMatchMarkerListImpl();
   }
@@ -182,6 +188,23 @@
   });
 }
 
+void DocumentMarkerController::AddSuggestionMarker(
+    const EphemeralRange& range,
+    const Vector<String>& suggestions,
+    Color suggestion_highlight_color,
+    Color underline_color,
+    StyleableMarker::Thickness thickness,
+    Color background_color) {
+  DCHECK(!document_->NeedsLayoutTreeUpdate());
+  AddMarkerInternal(
+      range, [this, &suggestions, suggestion_highlight_color, underline_color,
+              thickness, background_color](int start_offset, int end_offset) {
+        return new SuggestionMarker(start_offset, end_offset, suggestions,
+                                    suggestion_highlight_color, underline_color,
+                                    thickness, background_color);
+      });
+}
+
 void DocumentMarkerController::PrepareForDestruction() {
   Clear();
 }

third_party/WebKit/Source/core/editing/markers/DocumentMarkerController.h

diff --git a/third_party/WebKit/Source/core/editing/markers/DocumentMarkerController.h b/third_party/WebKit/Source/core/editing/markers/DocumentMarkerController.h
index c8a4e41..b4346918 100644
--- a/third_party/WebKit/Source/core/editing/markers/DocumentMarkerController.h
+++ b/third_party/WebKit/Source/core/editing/markers/DocumentMarkerController.h
@@ -34,6 +34,7 @@
 #include "core/editing/iterators/TextIterator.h"
 #include "core/editing/markers/CompositionMarker.h"
 #include "core/editing/markers/DocumentMarker.h"
+#include "core/editing/markers/SuggestionMarker.h"
 #include "core/editing/markers/TextMatchMarker.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/heap/Handle.h"
@@ -68,6 +69,12 @@
                                  Color underline_color,
                                  StyleableMarker::Thickness,
                                  Color background_color);
+  void AddSuggestionMarker(const EphemeralRange&,
+                           const Vector<String>& suggestions,
+                           Color suggestion_highlight_color,
+                           Color underline_color,
+                           StyleableMarker::Thickness,
+                           Color background_color);
 
   void MoveMarkers(Node* src_node, int length, Node* dst_node);
 

third_party/WebKit/Source/core/editing/markers/DocumentMarkerControllerTest.cpp

diff --git a/third_party/WebKit/Source/core/editing/markers/DocumentMarkerControllerTest.cpp b/third_party/WebKit/Source/core/editing/markers/DocumentMarkerControllerTest.cpp
index 9b4b50d..6936f34a 100644
--- a/third_party/WebKit/Source/core/editing/markers/DocumentMarkerControllerTest.cpp
+++ b/third_party/WebKit/Source/core/editing/markers/DocumentMarkerControllerTest.cpp
@@ -37,6 +37,7 @@
 #include "core/dom/Text.h"
 #include "core/editing/EditingTestBase.h"
 #include "core/editing/EphemeralRange.h"
+#include "core/editing/markers/SuggestionMarker.h"
 #include "core/html/HTMLElement.h"
 #include "core/testing/DummyPageHolder.h"
 #include "platform/wtf/RefPtr.h"
@@ -352,4 +353,23 @@
   EXPECT_EQ(3u, result->EndOffset());
 }
 
+TEST_F(DocumentMarkerControllerTest, SuggestionMarkersHaveUniqueTags) {
+  SetBodyContent("<div contenteditable>foo</div>");
+  Element* div = GetDocument().QuerySelector("div");
+  Node* text = div->firstChild();
+
+  MarkerController().AddSuggestionMarker(
+      EphemeralRange(Position(text, 0), Position(text, 1)), Vector<String>(),
+      Color::kBlack, Color::kBlack, StyleableMarker::Thickness::kThick,
+      Color::kBlack);
+  MarkerController().AddSuggestionMarker(
+      EphemeralRange(Position(text, 0), Position(text, 1)), Vector<String>(),
+      Color::kBlack, Color::kBlack, StyleableMarker::Thickness::kThick,
+      Color::kBlack);
+
+  EXPECT_EQ(2u, MarkerController().Markers().size());
+  EXPECT_NE(ToSuggestionMarker(MarkerController().Markers()[0])->Tag(),
+            ToSuggestionMarker(MarkerController().Markers()[1])->Tag());
+}
+
 }  // namespace blink

third_party/WebKit/Source/core/editing/markers/StyleableMarker.cpp

diff --git a/third_party/WebKit/Source/core/editing/markers/StyleableMarker.cpp b/third_party/WebKit/Source/core/editing/markers/StyleableMarker.cpp
index b80743e..9baaa8f 100644
--- a/third_party/WebKit/Source/core/editing/markers/StyleableMarker.cpp
+++ b/third_party/WebKit/Source/core/editing/markers/StyleableMarker.cpp
@@ -31,7 +31,8 @@
 bool IsStyleableMarker(const DocumentMarker& marker) {
   DocumentMarker::MarkerType type = marker.GetType();
   return type == DocumentMarker::kComposition ||
-         type == DocumentMarker::kActiveSuggestion;
+         type == DocumentMarker::kActiveSuggestion ||
+         type == DocumentMarker::kSuggestion;
 }
 
 }  // namespace blink

third_party/WebKit/Source/core/editing/markers/SuggestionMarker.cpp

diff --git a/third_party/WebKit/Source/core/editing/markers/SuggestionMarker.cpp b/third_party/WebKit/Source/core/editing/markers/SuggestionMarker.cpp
new file mode 100644
index 0000000..2351d47d
--- /dev/null
+++ b/third_party/WebKit/Source/core/editing/markers/SuggestionMarker.cpp
@@ -0,0 +1,56 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "core/editing/markers/SuggestionMarker.h"
+
+namespace blink {
+
+int32_t SuggestionMarker::current_tag_ = 0;
+
+SuggestionMarker::SuggestionMarker(unsigned start_offset,
+                                   unsigned end_offset,
+                                   const Vector<String>& suggestions,
+                                   Color suggestion_highlight_color,
+                                   Color underline_color,
+                                   Thickness thickness,
+                                   Color background_color)
+    : StyleableMarker(start_offset,
+                      end_offset,
+                      underline_color,
+                      thickness,
+                      background_color),
+      tag_(NextTag()),
+      suggestions_(suggestions),
+      suggestion_highlight_color_(suggestion_highlight_color) {
+  DCHECK_GT(tag_, 0);
+}
+
+int32_t SuggestionMarker::Tag() const {
+  return tag_;
+}
+
+DocumentMarker::MarkerType SuggestionMarker::GetType() const {
+  return DocumentMarker::kSuggestion;
+}
+
+const Vector<String>& SuggestionMarker::Suggestions() const {
+  return suggestions_;
+}
+
+Color SuggestionMarker::SuggestionHighlightColor() const {
+  return suggestion_highlight_color_;
+}
+
+void SuggestionMarker::SetSuggestion(uint32_t suggestion_index,
+                                     const String& new_suggestion) {
+  DCHECK_LT(suggestion_index, suggestions_.size());
+  suggestions_[suggestion_index] = new_suggestion;
+}
+
+// static
+int32_t SuggestionMarker::NextTag() {
+  return ++current_tag_;
+}
+
+}  // namespace blink

third_party/WebKit/Source/core/editing/markers/SuggestionMarker.h

diff --git a/third_party/WebKit/Source/core/editing/markers/SuggestionMarker.h b/third_party/WebKit/Source/core/editing/markers/SuggestionMarker.h
new file mode 100644
index 0000000..fdae4bc4
--- /dev/null
+++ b/third_party/WebKit/Source/core/editing/markers/SuggestionMarker.h
@@ -0,0 +1,61 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SuggestionMarker_h
+#define SuggestionMarker_h
+
+#include "core/editing/markers/StyleableMarker.h"
+
+namespace blink {
+
+// A subclass of StyleableMarker used to store information specific to
+// suggestion markers (used to represent Android SuggestionSpans). In addition
+// to the formatting information StyleableMarker holds, we also store a list of
+// suggested replacements for the marked region of text. In addition, each
+// SuggestionMarker is tagged with an integer so browser code can identify which
+// SuggestionMarker a suggestion replace operation pertains to.
+class CORE_EXPORT SuggestionMarker final : public StyleableMarker {
+ public:
+  SuggestionMarker(unsigned start_offset,
+                   unsigned end_offset,
+                   const Vector<String>& suggestions,
+                   Color suggestion_highlight_color,
+                   Color underline_color,
+                   Thickness,
+                   Color background_color);
+
+  // DocumentMarker implementations
+  MarkerType GetType() const final;
+
+  // SuggestionMarker-specific
+  int32_t Tag() const;
+  const Vector<String>& Suggestions() const;
+  Color SuggestionHighlightColor() const;
+
+  // Replace the suggestion at suggestion_index with new_suggestion.
+  void SetSuggestion(unsigned suggestion_index, const String& new_suggestion);
+
+ private:
+  static int32_t NextTag();
+
+  static int32_t current_tag_;
+
+  // We use a signed int for the tag since it's passed to Java (as an opaque
+  // identifier), and Java does not support unsigned ints.
+  const int32_t tag_;
+  Vector<String> suggestions_;
+  const Color suggestion_highlight_color_;
+
+  DISALLOW_COPY_AND_ASSIGN(SuggestionMarker);
+};
+
+DEFINE_TYPE_CASTS(SuggestionMarker,
+                  DocumentMarker,
+                  marker,
+                  marker->GetType() == DocumentMarker::kSuggestion,
+                  marker.GetType() == DocumentMarker::kSuggestion);
+
+}  // namespace blink
+
+#endif

third_party/WebKit/Source/core/editing/markers/SuggestionMarkerListImpl.cpp

diff --git a/third_party/WebKit/Source/core/editing/markers/SuggestionMarkerListImpl.cpp b/third_party/WebKit/Source/core/editing/markers/SuggestionMarkerListImpl.cpp
new file mode 100644
index 0000000..cd7f3119
--- /dev/null
+++ b/third_party/WebKit/Source/core/editing/markers/SuggestionMarkerListImpl.cpp
@@ -0,0 +1,145 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "core/editing/markers/SuggestionMarkerListImpl.h"
+
+#include "core/editing/markers/DocumentMarkerListEditor.h"
+
+namespace blink {
+
+DocumentMarker::MarkerType SuggestionMarkerListImpl::MarkerType() const {
+  return DocumentMarker::kSuggestion;
+}
+
+bool SuggestionMarkerListImpl::IsEmpty() const {
+  return markers_.IsEmpty();
+}
+
+void SuggestionMarkerListImpl::Add(DocumentMarker* marker) {
+  markers_.push_back(marker);
+}
+
+void SuggestionMarkerListImpl::Clear() {
+  markers_.clear();
+}
+
+const HeapVector<Member<DocumentMarker>>& SuggestionMarkerListImpl::GetMarkers()
+    const {
+  return markers_;
+}
+
+DocumentMarker* SuggestionMarkerListImpl::FirstMarkerIntersectingRange(
+    unsigned start_offset,
+    unsigned end_offset) const {
+  DCHECK_LE(start_offset, end_offset);
+
+  const auto it =
+      std::find_if(markers_.begin(), markers_.end(),
+                   [start_offset, end_offset](const DocumentMarker* marker) {
+                     return marker->StartOffset() < end_offset &&
+                            marker->EndOffset() > start_offset;
+                   });
+
+  if (it == markers_.end())
+    return nullptr;
+  return *it;
+}
+
+HeapVector<Member<DocumentMarker>>
+SuggestionMarkerListImpl::MarkersIntersectingRange(unsigned start_offset,
+                                                   unsigned end_offset) const {
+  DCHECK_LE(start_offset, end_offset);
+
+  HeapVector<Member<DocumentMarker>> results;
+  std::copy_if(markers_.begin(), markers_.end(), std::back_inserter(results),
+               [start_offset, end_offset](const DocumentMarker* marker) {
+                 return marker->StartOffset() < end_offset &&
+                        marker->EndOffset() > start_offset;
+               });
+  return results;
+}
+
+bool SuggestionMarkerListImpl::MoveMarkers(int length,
+                                           DocumentMarkerList* dst_list) {
+  DCHECK_GT(length, 0);
+  bool did_move_marker = false;
+  unsigned end_offset = length - 1;
+
+  HeapVector<Member<DocumentMarker>> unmoved_markers;
+  for (auto it = markers_.begin(); it != markers_.end(); ++it) {
+    DocumentMarker& marker = **it;
+    if (marker.StartOffset() > end_offset) {
+      unmoved_markers.push_back(marker);
+      continue;
+    }
+
+    // If we're splitting a text node in the middle of a suggestion marker,
+    // remove the marker
+    if (marker.EndOffset() > end_offset)
+      continue;
+
+    dst_list->Add(&marker);
+    did_move_marker = true;
+  }
+
+  markers_ = std::move(unmoved_markers);
+  return did_move_marker;
+}
+
+bool SuggestionMarkerListImpl::RemoveMarkers(unsigned start_offset,
+                                             int length) {
+  // Since suggestion markers are stored unsorted, the quickest way to perform
+  // this operation is to build a new list with the markers that aren't being
+  // removed.
+  const unsigned end_offset = start_offset + length;
+  HeapVector<Member<DocumentMarker>> unremoved_markers;
+  for (const Member<DocumentMarker>& marker : markers_) {
+    if (marker->EndOffset() <= start_offset ||
+        marker->StartOffset() >= end_offset) {
+      unremoved_markers.push_back(marker);
+      continue;
+    }
+  }
+
+  const bool did_remove_marker = (unremoved_markers.size() != markers_.size());
+  markers_ = std::move(unremoved_markers);
+  return did_remove_marker;
+}
+
+bool SuggestionMarkerListImpl::ShiftMarkers(unsigned offset,
+                                            unsigned old_length,
+                                            unsigned new_length) {
+  // Since suggestion markers are stored unsorted, the quickest way to perform
+  // this operation is to build a new list with the markers not removed by the
+  // shift.
+  bool did_shift_marker = false;
+  HeapVector<Member<DocumentMarker>> unremoved_markers;
+  for (const Member<DocumentMarker>& marker : markers_) {
+    Optional<DocumentMarker::MarkerOffsets> result =
+        marker->ComputeOffsetsAfterShift(offset, old_length, new_length);
+    if (result == WTF::nullopt) {
+      did_shift_marker = true;
+      continue;
+    }
+
+    if (marker->StartOffset() != result.value().start_offset ||
+        marker->EndOffset() != result.value().end_offset) {
+      marker->SetStartOffset(result.value().start_offset);
+      marker->SetEndOffset(result.value().end_offset);
+      did_shift_marker = true;
+    }
+
+    unremoved_markers.push_back(marker);
+  }
+
+  markers_ = std::move(unremoved_markers);
+  return did_shift_marker;
+}
+
+DEFINE_TRACE(SuggestionMarkerListImpl) {
+  visitor->Trace(markers_);
+  DocumentMarkerList::Trace(visitor);
+}
+
+}  // namespace blink

third_party/WebKit/Source/core/editing/markers/SuggestionMarkerListImpl.h

diff --git a/third_party/WebKit/Source/core/editing/markers/SuggestionMarkerListImpl.h b/third_party/WebKit/Source/core/editing/markers/SuggestionMarkerListImpl.h
new file mode 100644
index 0000000..0149e64
--- /dev/null
+++ b/third_party/WebKit/Source/core/editing/markers/SuggestionMarkerListImpl.h
@@ -0,0 +1,52 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SuggestionMarkerListImpl_h
+#define SuggestionMarkerListImpl_h
+
+#include "core/editing/markers/DocumentMarkerList.h"
+
+namespace blink {
+
+// Implementation of DocumentMarkerList for Suggestion markers. Suggestion
+// markers are somewhat unusual compared to some other MarkerTypes in that they
+// can overlap. Since sorting by start offset doesn't help very much when the
+// markers can overlap, and other ways of doing this efficiently would add a lot
+// of complexity, suggestion markers are currently stored unsorted.
+class CORE_EXPORT SuggestionMarkerListImpl final : public DocumentMarkerList {
+ public:
+  SuggestionMarkerListImpl() = default;
+
+  // DocumentMarkerList implementations
+  DocumentMarker::MarkerType MarkerType() const final;
+
+  bool IsEmpty() const final;
+
+  void Add(DocumentMarker*) final;
+  void Clear() final;
+
+  const HeapVector<Member<DocumentMarker>>& GetMarkers() const final;
+  DocumentMarker* FirstMarkerIntersectingRange(unsigned start_offset,
+                                               unsigned end_offset) const final;
+  HeapVector<Member<DocumentMarker>> MarkersIntersectingRange(
+      unsigned start_offset,
+      unsigned end_offset) const final;
+
+  bool MoveMarkers(int length, DocumentMarkerList* dst_list) final;
+  bool RemoveMarkers(unsigned start_offset, int length) final;
+  bool ShiftMarkers(unsigned offset,
+                    unsigned old_length,
+                    unsigned new_length) final;
+
+  DECLARE_VIRTUAL_TRACE();
+
+ private:
+  HeapVector<Member<DocumentMarker>> markers_;
+
+  DISALLOW_COPY_AND_ASSIGN(SuggestionMarkerListImpl);
+};
+
+}  // namespace blink
+
+#endif  // SuggestionMarkerListImpl_h

third_party/WebKit/Source/core/editing/markers/SuggestionMarkerListImplTest.cpp

diff --git a/third_party/WebKit/Source/core/editing/markers/SuggestionMarkerListImplTest.cpp b/third_party/WebKit/Source/core/editing/markers/SuggestionMarkerListImplTest.cpp
new file mode 100644
index 0000000..8fa41f6
--- /dev/null
+++ b/third_party/WebKit/Source/core/editing/markers/SuggestionMarkerListImplTest.cpp
@@ -0,0 +1,284 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.  Use of
+// this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "core/editing/markers/SuggestionMarkerListImpl.h"
+
+#include "core/editing/markers/SuggestionMarker.h"
+#include "platform/heap/Handle.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace blink {
+
+class SuggestionMarkerListImplTest : public ::testing::Test {
+ protected:
+  SuggestionMarkerListImplTest()
+      : marker_list_(new SuggestionMarkerListImpl()) {}
+
+  DocumentMarker* CreateMarker(unsigned start_offset, unsigned end_offset) {
+    return new SuggestionMarker(start_offset, end_offset, Vector<String>(),
+                                Color::kTransparent, Color::kTransparent,
+                                StyleableMarker::Thickness::kThin,
+                                Color::kTransparent);
+  }
+
+  Persistent<SuggestionMarkerListImpl> marker_list_;
+};
+
+namespace {
+
+bool compare_markers(const Member<DocumentMarker>& marker1,
+                     const Member<DocumentMarker>& marker2) {
+  if (marker1->StartOffset() != marker2->StartOffset())
+    return marker1->StartOffset() < marker2->StartOffset();
+
+  return marker1->EndOffset() < marker2->EndOffset();
+}
+}  // namespace
+
+TEST_F(SuggestionMarkerListImplTest, MarkerType) {
+  EXPECT_EQ(DocumentMarker::kSuggestion, marker_list_->MarkerType());
+}
+
+TEST_F(SuggestionMarkerListImplTest, AddOverlapping) {
+  // Add some overlapping markers in an arbitrary order and verify that the
+  // list stores them properly
+  marker_list_->Add(CreateMarker(40, 50));
+  marker_list_->Add(CreateMarker(10, 40));
+  marker_list_->Add(CreateMarker(20, 50));
+  marker_list_->Add(CreateMarker(10, 30));
+  marker_list_->Add(CreateMarker(10, 50));
+  marker_list_->Add(CreateMarker(30, 50));
+  marker_list_->Add(CreateMarker(30, 40));
+  marker_list_->Add(CreateMarker(10, 20));
+  marker_list_->Add(CreateMarker(20, 40));
+  marker_list_->Add(CreateMarker(20, 30));
+
+  DocumentMarkerVector markers = marker_list_->GetMarkers();
+  std::sort(markers.begin(), markers.end(), compare_markers);
+
+  EXPECT_EQ(10u, markers.size());
+
+  EXPECT_EQ(10u, markers[0]->StartOffset());
+  EXPECT_EQ(20u, markers[0]->EndOffset());
+
+  EXPECT_EQ(10u, markers[1]->StartOffset());
+  EXPECT_EQ(30u, markers[1]->EndOffset());
+
+  EXPECT_EQ(10u, markers[2]->StartOffset());
+  EXPECT_EQ(40u, markers[2]->EndOffset());
+
+  EXPECT_EQ(10u, markers[3]->StartOffset());
+  EXPECT_EQ(50u, markers[3]->EndOffset());
+
+  EXPECT_EQ(20u, markers[4]->StartOffset());
+  EXPECT_EQ(30u, markers[4]->EndOffset());
+
+  EXPECT_EQ(20u, markers[5]->StartOffset());
+  EXPECT_EQ(40u, markers[5]->EndOffset());
+
+  EXPECT_EQ(20u, markers[6]->StartOffset());
+  EXPECT_EQ(50u, markers[6]->EndOffset());
+
+  EXPECT_EQ(30u, markers[7]->StartOffset());
+  EXPECT_EQ(40u, markers[7]->EndOffset());
+
+  EXPECT_EQ(30u, markers[8]->StartOffset());
+  EXPECT_EQ(50u, markers[8]->EndOffset());
+
+  EXPECT_EQ(40u, markers[9]->StartOffset());
+  EXPECT_EQ(50u, markers[9]->EndOffset());
+}
+
+TEST_F(SuggestionMarkerListImplTest, FirstMarkerIntersectingRange_Empty) {
+  DocumentMarker* marker = marker_list_->FirstMarkerIntersectingRange(0, 10);
+  EXPECT_EQ(nullptr, marker);
+}
+
+TEST_F(SuggestionMarkerListImplTest,
+       FirstMarkerIntersectingRange_TouchingStart) {
+  marker_list_->Add(CreateMarker(1, 10));
+  marker_list_->Add(CreateMarker(0, 10));
+
+  DocumentMarker* marker = marker_list_->FirstMarkerIntersectingRange(0, 1);
+
+  EXPECT_NE(nullptr, marker);
+  EXPECT_EQ(0u, marker->StartOffset());
+  EXPECT_EQ(10u, marker->EndOffset());
+}
+
+TEST_F(SuggestionMarkerListImplTest, FirstMarkerIntersectingRange_TouchingEnd) {
+  marker_list_->Add(CreateMarker(0, 9));
+  marker_list_->Add(CreateMarker(0, 10));
+
+  DocumentMarker* marker = marker_list_->FirstMarkerIntersectingRange(9, 10);
+
+  EXPECT_NE(nullptr, marker);
+  EXPECT_EQ(0u, marker->StartOffset());
+  EXPECT_EQ(10u, marker->EndOffset());
+}
+
+TEST_F(SuggestionMarkerListImplTest, MarkersIntersectingRange_TouchingStart) {
+  marker_list_->Add(CreateMarker(0, 9));
+  marker_list_->Add(CreateMarker(1, 9));
+  marker_list_->Add(CreateMarker(0, 10));
+  marker_list_->Add(CreateMarker(1, 10));
+
+  DocumentMarkerVector markers_intersecting_range =
+      marker_list_->MarkersIntersectingRange(0, 1);
+
+  EXPECT_EQ(2u, markers_intersecting_range.size());
+
+  EXPECT_EQ(0u, markers_intersecting_range[0]->StartOffset());
+  EXPECT_EQ(9u, markers_intersecting_range[0]->EndOffset());
+
+  EXPECT_EQ(0u, markers_intersecting_range[1]->StartOffset());
+  EXPECT_EQ(10u, markers_intersecting_range[1]->EndOffset());
+}
+
+TEST_F(SuggestionMarkerListImplTest, MarkersIntersectingRange_TouchingEnd) {
+  marker_list_->Add(CreateMarker(0, 9));
+  marker_list_->Add(CreateMarker(1, 9));
+  marker_list_->Add(CreateMarker(0, 10));
+  marker_list_->Add(CreateMarker(1, 10));
+
+  DocumentMarkerVector markers_intersecting_range =
+      marker_list_->MarkersIntersectingRange(9, 10);
+
+  EXPECT_EQ(2u, markers_intersecting_range.size());
+
+  EXPECT_EQ(0u, markers_intersecting_range[0]->StartOffset());
+  EXPECT_EQ(10u, markers_intersecting_range[0]->EndOffset());
+
+  EXPECT_EQ(1u, markers_intersecting_range[1]->StartOffset());
+  EXPECT_EQ(10u, markers_intersecting_range[1]->EndOffset());
+}
+
+TEST_F(SuggestionMarkerListImplTest, MoveMarkers) {
+  marker_list_->Add(CreateMarker(30, 40));
+  marker_list_->Add(CreateMarker(0, 30));
+  marker_list_->Add(CreateMarker(10, 40));
+  marker_list_->Add(CreateMarker(0, 20));
+  marker_list_->Add(CreateMarker(0, 40));
+  marker_list_->Add(CreateMarker(20, 40));
+  marker_list_->Add(CreateMarker(20, 30));
+  marker_list_->Add(CreateMarker(0, 10));
+  marker_list_->Add(CreateMarker(10, 30));
+  marker_list_->Add(CreateMarker(10, 20));
+  marker_list_->Add(CreateMarker(11, 21));
+
+  DocumentMarkerList* dst_list = new SuggestionMarkerListImpl();
+  // The markers with start and end offset < 11 should be moved to dst_list.
+  // Markers that start before 11 and end at 11 or later should be removed.
+  // Markers that start at 11 or later should not be moved.
+  marker_list_->MoveMarkers(11, dst_list);
+
+  DocumentMarkerVector source_list_markers = marker_list_->GetMarkers();
+  std::sort(source_list_markers.begin(), source_list_markers.end(),
+            compare_markers);
+
+  EXPECT_EQ(4u, source_list_markers.size());
+
+  EXPECT_EQ(11u, source_list_markers[0]->StartOffset());
+  EXPECT_EQ(21u, source_list_markers[0]->EndOffset());
+
+  EXPECT_EQ(20u, source_list_markers[1]->StartOffset());
+  EXPECT_EQ(30u, source_list_markers[1]->EndOffset());
+
+  EXPECT_EQ(20u, source_list_markers[2]->StartOffset());
+  EXPECT_EQ(40u, source_list_markers[2]->EndOffset());
+
+  EXPECT_EQ(30u, source_list_markers[3]->StartOffset());
+  EXPECT_EQ(40u, source_list_markers[3]->EndOffset());
+
+  DocumentMarkerVector dst_list_markers = dst_list->GetMarkers();
+  std::sort(dst_list_markers.begin(), dst_list_markers.end(), compare_markers);
+
+  // Markers
+  EXPECT_EQ(1u, dst_list_markers.size());
+
+  EXPECT_EQ(0u, dst_list_markers[0]->StartOffset());
+  EXPECT_EQ(10u, dst_list_markers[0]->EndOffset());
+}
+
+TEST_F(SuggestionMarkerListImplTest, RemoveMarkersEmptyList) {
+  EXPECT_FALSE(marker_list_->RemoveMarkers(0, 10));
+  EXPECT_EQ(0u, marker_list_->GetMarkers().size());
+}
+
+TEST_F(SuggestionMarkerListImplTest, RemoveMarkersTouchingEndpoints) {
+  marker_list_->Add(CreateMarker(30, 40));
+  marker_list_->Add(CreateMarker(40, 50));
+  marker_list_->Add(CreateMarker(10, 20));
+  marker_list_->Add(CreateMarker(0, 10));
+  marker_list_->Add(CreateMarker(20, 30));
+
+  EXPECT_TRUE(marker_list_->RemoveMarkers(20, 10));
+
+  DocumentMarkerVector markers = marker_list_->GetMarkers();
+  std::sort(markers.begin(), markers.end(), compare_markers);
+
+  EXPECT_EQ(4u, markers.size());
+
+  EXPECT_EQ(0u, markers[0]->StartOffset());
+  EXPECT_EQ(10u, markers[0]->EndOffset());
+
+  EXPECT_EQ(10u, markers[1]->StartOffset());
+  EXPECT_EQ(20u, markers[1]->EndOffset());
+
+  EXPECT_EQ(30u, markers[2]->StartOffset());
+  EXPECT_EQ(40u, markers[2]->EndOffset());
+
+  EXPECT_EQ(40u, markers[3]->StartOffset());
+  EXPECT_EQ(50u, markers[3]->EndOffset());
+}
+
+TEST_F(SuggestionMarkerListImplTest, RemoveMarkersOneCharacterIntoInterior) {
+  marker_list_->Add(CreateMarker(30, 40));
+  marker_list_->Add(CreateMarker(40, 50));
+  marker_list_->Add(CreateMarker(10, 20));
+  marker_list_->Add(CreateMarker(0, 10));
+  marker_list_->Add(CreateMarker(20, 30));
+
+  EXPECT_TRUE(marker_list_->RemoveMarkers(19, 12));
+
+  DocumentMarkerVector markers = marker_list_->GetMarkers();
+  std::sort(markers.begin(), markers.end(), compare_markers);
+
+  EXPECT_EQ(2u, markers.size());
+
+  EXPECT_EQ(0u, markers[0]->StartOffset());
+  EXPECT_EQ(10u, markers[0]->EndOffset());
+
+  EXPECT_EQ(40u, markers[1]->StartOffset());
+  EXPECT_EQ(50u, markers[1]->EndOffset());
+}
+
+TEST_F(SuggestionMarkerListImplTest, ShiftMarkers) {
+  marker_list_->Add(CreateMarker(30, 40));
+  marker_list_->Add(CreateMarker(40, 50));
+  marker_list_->Add(CreateMarker(10, 20));
+  marker_list_->Add(CreateMarker(0, 10));
+  marker_list_->Add(CreateMarker(20, 30));
+
+  EXPECT_TRUE(marker_list_->ShiftMarkers(15, 20, 0));
+
+  DocumentMarkerVector markers = marker_list_->GetMarkers();
+  std::sort(markers.begin(), markers.end(), compare_markers);
+
+  EXPECT_EQ(4u, markers.size());
+
+  EXPECT_EQ(0u, markers[0]->StartOffset());
+  EXPECT_EQ(10u, markers[0]->EndOffset());
+
+  EXPECT_EQ(10u, markers[1]->StartOffset());
+  EXPECT_EQ(15u, markers[1]->EndOffset());
+
+  EXPECT_EQ(15u, markers[2]->StartOffset());
+  EXPECT_EQ(20u, markers[2]->EndOffset());
+
+  EXPECT_EQ(20u, markers[3]->StartOffset());
+  EXPECT_EQ(30u, markers[3]->EndOffset());
+}
+
+}  // namespace blink

third_party/WebKit/Source/core/editing/markers/SuggestionMarkerTest.cpp

diff --git a/third_party/WebKit/Source/core/editing/markers/SuggestionMarkerTest.cpp b/third_party/WebKit/Source/core/editing/markers/SuggestionMarkerTest.cpp
new file mode 100644
index 0000000..08ab379
--- /dev/null
+++ b/third_party/WebKit/Source/core/editing/markers/SuggestionMarkerTest.cpp
@@ -0,0 +1,59 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "core/editing/markers/SuggestionMarker.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace blink {
+
+class SuggestionMarkerTest : public ::testing::Test {};
+
+TEST_F(SuggestionMarkerTest, MarkerType) {
+  DocumentMarker* marker = new SuggestionMarker(
+      0, 1, Vector<String>(), Color::kTransparent, Color::kTransparent,
+      StyleableMarker::Thickness::kThin, Color::kTransparent);
+  EXPECT_EQ(DocumentMarker::kSuggestion, marker->GetType());
+}
+
+TEST_F(SuggestionMarkerTest, IsStyleableMarker) {
+  DocumentMarker* marker = new SuggestionMarker(
+      0, 1, Vector<String>(), Color::kTransparent, Color::kTransparent,
+      StyleableMarker::Thickness::kThin, Color::kTransparent);
+  EXPECT_TRUE(IsStyleableMarker(*marker));
+}
+
+TEST_F(SuggestionMarkerTest, ConstructorAndGetters) {
+  Vector<String> suggestions = {"this", "that"};
+  SuggestionMarker* marker = new SuggestionMarker(
+      0, 1, suggestions, Color::kTransparent, Color::kDarkGray,
+      StyleableMarker::Thickness::kThin, Color::kGray);
+  EXPECT_EQ(suggestions, marker->Suggestions());
+  EXPECT_EQ(Color::kTransparent, marker->SuggestionHighlightColor());
+  EXPECT_EQ(Color::kDarkGray, marker->UnderlineColor());
+  EXPECT_FALSE(marker->IsThick());
+  EXPECT_EQ(Color::kGray, marker->BackgroundColor());
+
+  SuggestionMarker* marker2 = new SuggestionMarker(
+      0, 1, Vector<String>(), Color::kBlack, Color::kDarkGray,
+      StyleableMarker::Thickness::kThick, Color::kGray);
+  EXPECT_TRUE(marker2->IsThick());
+  EXPECT_EQ(marker2->SuggestionHighlightColor(), Color::kBlack);
+}
+
+TEST_F(SuggestionMarkerTest, SetSuggestion) {
+  Vector<String> suggestions = {"this", "that"};
+  SuggestionMarker* marker = new SuggestionMarker(
+      0, 1, suggestions, Color::kTransparent, Color::kDarkGray,
+      StyleableMarker::Thickness::kThin, Color::kGray);
+
+  marker->SetSuggestion(1, "these");
+
+  EXPECT_EQ(2u, marker->Suggestions().size());
+
+  EXPECT_EQ("this", marker->Suggestions()[0]);
+  EXPECT_EQ("these", marker->Suggestions()[1]);
+}
+
+}  // namespace blink

third_party/WebKit/Source/core/paint/BlockPainter.cpp

diff --git a/third_party/WebKit/Source/core/paint/BlockPainter.cpp b/third_party/WebKit/Source/core/paint/BlockPainter.cpp
index 74f59ac1..06b04b4 100644
--- a/third_party/WebKit/Source/core/paint/BlockPainter.cpp
+++ b/third_party/WebKit/Source/core/paint/BlockPainter.cpp
@@ -23,6 +23,8 @@
 #include "core/paint/ScrollableAreaPainter.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/paint/ClipRecorder.h"
+#include "platform/graphics/paint/ScopedPaintChunkProperties.h"
+#include "platform/graphics/paint/ScrollHitTestDisplayItem.h"
 #include "platform/wtf/Optional.h"
 
 namespace blink {
@@ -164,6 +166,48 @@
       .PaintAllPhasesAtomically(paint_info, child_point);
 }
 
+void BlockPainter::PaintScrollHitTestDisplayItem(const PaintInfo& paint_info) {
+  DCHECK(RuntimeEnabledFeatures::SlimmingPaintV2Enabled());
+  // Without RootLayerScrolling, the LayoutView will not create scroll paint
+  // properties and will rely on the LocalFrameView providing a scroll
+  // translation property.
+  if (!RuntimeEnabledFeatures::RootLayerScrollingEnabled() &&
+      layout_block_.IsLayoutView()) {
+    auto* view = layout_block_.GetFrame()->View();
+    auto* contents_state = view->TotalPropertyTreeStateForContents();
+    // Paint chunk properties should already be setup to be under the root
+    // frame's scroll translation node so a property scope is not needed.
+    DCHECK(paint_info.context.GetPaintController()
+               .CurrentPaintChunkProperties()
+               .property_tree_state.Transform() == contents_state->Transform());
+    if (contents_state->Transform()->ScrollNode()) {
+      ScrollHitTestDisplayItem::Record(paint_info.context, layout_block_,
+                                       DisplayItem::kScrollHitTest);
+    }
+    // The LayoutView should not create a scroll translation or scroll node,
+    // instead relying on the LocalFrameView's scroll translation and scroll.
+    const auto* properties =
+        layout_block_.FirstFragment()
+            ? layout_block_.FirstFragment()->PaintProperties()
+            : nullptr;
+    DCHECK(!properties ||
+           (!properties->ScrollTranslation() && !properties->Scroll()));
+    return;
+  }
+
+  const auto* properties =
+      layout_block_.FirstFragment()
+          ? layout_block_.FirstFragment()->PaintProperties()
+          : nullptr;
+  if (properties && properties->Scroll()) {
+    ScopedPaintChunkProperties scroll_properties(
+        paint_info.context.GetPaintController(), layout_block_,
+        layout_block_.FirstFragment()->ContentsProperties());
+    ScrollHitTestDisplayItem::Record(paint_info.context, layout_block_,
+                                     DisplayItem::kScrollHitTest);
+  }
+}
+
 DISABLE_CFI_PERF
 void BlockPainter::PaintObject(const PaintInfo& paint_info,
                                const LayoutPoint& paint_offset) {
@@ -176,6 +220,11 @@
     if (layout_block_.Style()->Visibility() == EVisibility::kVisible &&
         layout_block_.HasBoxDecorationBackground())
       layout_block_.PaintBoxDecorationBackground(paint_info, paint_offset);
+    // Record the scroll hit test after the background so background squashing
+    // is not affected. Hit test order would be equivalent if this were
+    // immediately before the background.
+    if (RuntimeEnabledFeatures::SlimmingPaintV2Enabled())
+      PaintScrollHitTestDisplayItem(paint_info);
     // We're done. We don't bother painting any children.
     if (paint_phase == kPaintPhaseSelfBlockBackgroundOnly)
       return;

third_party/WebKit/Source/core/paint/BlockPainter.h

diff --git a/third_party/WebKit/Source/core/paint/BlockPainter.h b/third_party/WebKit/Source/core/paint/BlockPainter.h
index 4952077..bf129b4 100644
--- a/third_party/WebKit/Source/core/paint/BlockPainter.h
+++ b/third_party/WebKit/Source/core/paint/BlockPainter.h
@@ -46,6 +46,9 @@
                            const LayoutPoint& adjusted_paint_offset) const;
 
  private:
+  // Paint scroll hit test placeholders in the correct paint order (see:
+  // ScrollHitTestDisplayItem.h).
+  void PaintScrollHitTestDisplayItem(const PaintInfo&);
   void PaintCarets(const PaintInfo&, const LayoutPoint&);
 
   const LayoutBlock& layout_block_;

third_party/WebKit/Source/core/paint/PaintControllerPaintTest.cpp

diff --git a/third_party/WebKit/Source/core/paint/PaintControllerPaintTest.cpp b/third_party/WebKit/Source/core/paint/PaintControllerPaintTest.cpp
index c474094e..4f41e0cc 100644
--- a/third_party/WebKit/Source/core/paint/PaintControllerPaintTest.cpp
+++ b/third_party/WebKit/Source/core/paint/PaintControllerPaintTest.cpp
@@ -192,8 +192,9 @@
   auto& div4 = *GetLayoutObjectByElementId("div4");
 
   // Initial cull rect: (0,0 4800x4600)
-  EXPECT_DISPLAY_LIST(RootPaintController().GetDisplayItemList(), 3,
+  EXPECT_DISPLAY_LIST(RootPaintController().GetDisplayItemList(), 4,
                       TestDisplayItem(GetLayoutView(), kDocumentBackgroundType),
+                      TestDisplayItem(GetLayoutView(), kScrollHitTestType),
                       TestDisplayItem(div1, kBackgroundType),
                       TestDisplayItem(div2, kBackgroundType));
 
@@ -202,8 +203,9 @@
   GetDocument().View()->UpdateAllLifecyclePhases();
 
   // Cull rect after scroll: (1000,1000 8800x8600)
-  EXPECT_DISPLAY_LIST(RootPaintController().GetDisplayItemList(), 4,
+  EXPECT_DISPLAY_LIST(RootPaintController().GetDisplayItemList(), 5,
                       TestDisplayItem(GetLayoutView(), kDocumentBackgroundType),
+                      TestDisplayItem(GetLayoutView(), kScrollHitTestType),
                       TestDisplayItem(div2, kBackgroundType),
                       TestDisplayItem(div3, kBackgroundType),
                       TestDisplayItem(div4, kBackgroundType));
@@ -235,8 +237,9 @@
   auto& div4 = *GetLayoutObjectByElementId("div4");
 
   // Initial cull rect: (0,0 4200x4200)
-  EXPECT_DISPLAY_LIST(RootPaintController().GetDisplayItemList(), 3,
+  EXPECT_DISPLAY_LIST(RootPaintController().GetDisplayItemList(), 4,
                       TestDisplayItem(GetLayoutView(), kDocumentBackgroundType),
+                      TestDisplayItem(container, kScrollHitTestType),
                       TestDisplayItem(div1, kBackgroundType),
                       TestDisplayItem(div2, kBackgroundType));
 
@@ -245,11 +248,156 @@
   GetDocument().View()->UpdateAllLifecyclePhases();
 
   // Cull rect after scroll: (1000,1000 8100x8100)
-  EXPECT_DISPLAY_LIST(RootPaintController().GetDisplayItemList(), 4,
+  EXPECT_DISPLAY_LIST(RootPaintController().GetDisplayItemList(), 5,
                       TestDisplayItem(GetLayoutView(), kDocumentBackgroundType),
+                      TestDisplayItem(container, kScrollHitTestType),
                       TestDisplayItem(div2, kBackgroundType),
                       TestDisplayItem(div3, kBackgroundType),
                       TestDisplayItem(div4, kBackgroundType));
 }
 
+TEST_P(PaintControllerPaintTestForSlimmingPaintV2, ScrollHitTestOrder) {
+  SetBodyInnerHTML(
+      "<style>"
+      "  ::-webkit-scrollbar { display: none }"
+      "  body { margin: 0 }"
+      "  #container { width: 200px; height: 200px;"
+      "              overflow: scroll; background: red; }"
+      "  #child { width: 100px; height: 300px; background: green; }"
+      "  #forceDocumentScroll { height: 1000px; }"
+      "</style>"
+      "<div id='container'>"
+      "  <div id='child'></div>"
+      "</div>"
+      "<div id='forceDocumentScroll'/>");
+
+  auto& container = *ToLayoutBlock(GetLayoutObjectByElementId("container"));
+  auto& child = *GetLayoutObjectByElementId("child");
+
+  // The container's items should all be after the document's scroll hit test
+  // to ensure the container is hit before the document. Similarly, the child's
+  // items should all be after the container's scroll hit test.
+  EXPECT_DISPLAY_LIST(RootPaintController().GetDisplayItemList(), 5,
+                      TestDisplayItem(GetLayoutView(), kDocumentBackgroundType),
+                      TestDisplayItem(GetLayoutView(), kScrollHitTestType),
+                      TestDisplayItem(container, kBackgroundType),
+                      TestDisplayItem(container, kScrollHitTestType),
+                      TestDisplayItem(child, kBackgroundType));
+}
+
+TEST_P(PaintControllerPaintTestForSlimmingPaintV2,
+       NonStackingScrollHitTestOrder) {
+  SetBodyInnerHTML(
+      "<style>"
+      "  ::-webkit-scrollbar { display: none }"
+      "  body { margin: 0 }"
+      "  #container { width: 200px; height: 200px;"
+      "              overflow: scroll; background: blue;"
+      "              position: relative; z-index: auto; }"
+      "  #child { width: 80px; height: 20px; background: white; }"
+      "  #negZChild { width: 60px; height: 300px; background: purple;"
+      "               position: absolute; z-index: -1; top: 0; }"
+      "  #posZChild { width: 40px; height: 300px; background: yellow;"
+      "               position: absolute; z-index: 1; top: 0; }"
+      "</style>"
+      "<div id='container'>"
+      "  <div id='child'></div>"
+      "  <div id='negZChild'></div>"
+      "  <div id='posZChild'></div>"
+      "</div>");
+
+  auto& container = *ToLayoutBlock(GetLayoutObjectByElementId("container"));
+  auto& child = *GetLayoutObjectByElementId("child");
+  auto& neg_z_child = *GetLayoutObjectByElementId("negZChild");
+  auto& pos_z_child = *GetLayoutObjectByElementId("posZChild");
+
+  // Container is not a stacking context because no z-index is auto.
+  // Negative z-index descendants are painted before the background and
+  // positive z-index descendants are painted after the background. Scroll hit
+  // testing should hit positive descendants, the container, and then negative
+  // descendants so the ScrollHitTest item should be immediately after the
+  // background.
+  EXPECT_DISPLAY_LIST(RootPaintController().GetDisplayItemList(), 6,
+                      TestDisplayItem(GetLayoutView(), kDocumentBackgroundType),
+                      TestDisplayItem(neg_z_child, kBackgroundType),
+                      TestDisplayItem(container, kBackgroundType),
+                      TestDisplayItem(container, kScrollHitTestType),
+                      TestDisplayItem(child, kBackgroundType),
+                      TestDisplayItem(pos_z_child, kBackgroundType));
+}
+
+TEST_P(PaintControllerPaintTestForSlimmingPaintV2, StackingScrollHitTestOrder) {
+  SetBodyInnerHTML(
+      "<style>"
+      "  ::-webkit-scrollbar { display: none }"
+      "  body { margin: 0 }"
+      "  #container { width: 200px; height: 200px;"
+      "              overflow: scroll; background: blue;"
+      "              position: relative; z-index: 0; }"
+      "  #child { width: 80px; height: 20px; background: white; }"
+      "  #negZChild { width: 60px; height: 300px; background: purple;"
+      "               position: absolute; z-index: -1; top: 0; }"
+      "  #posZChild { width: 40px; height: 300px; background: yellow;"
+      "               position: absolute; z-index: 1; top: 0; }"
+      "</style>"
+      "<div id='container'>"
+      "  <div id='child'></div>"
+      "  <div id='negZChild'></div>"
+      "  <div id='posZChild'></div>"
+      "</div>");
+
+  auto& container = *ToLayoutBlock(GetLayoutObjectByElementId("container"));
+  auto& child = *GetLayoutObjectByElementId("child");
+  auto& neg_z_child = *GetLayoutObjectByElementId("negZChild");
+  auto& pos_z_child = *GetLayoutObjectByElementId("posZChild");
+
+  // Container is a stacking context because z-index is non-auto.
+  // Both positive and negative z-index descendants are painted after the
+  // background. The scroll hit test should be after the background but before
+  // the z-index descendants to ensure hit test order is correct.
+  EXPECT_DISPLAY_LIST(RootPaintController().GetDisplayItemList(), 6,
+                      TestDisplayItem(GetLayoutView(), kDocumentBackgroundType),
+                      TestDisplayItem(container, kBackgroundType),
+                      TestDisplayItem(container, kScrollHitTestType),
+                      TestDisplayItem(neg_z_child, kBackgroundType),
+                      TestDisplayItem(child, kBackgroundType),
+                      TestDisplayItem(pos_z_child, kBackgroundType));
+}
+
+TEST_P(PaintControllerPaintTestForSlimmingPaintV2,
+       NonStackingScrollHitTestOrderWithoutBackground) {
+  SetBodyInnerHTML(
+      "<style>"
+      "  ::-webkit-scrollbar { display: none }"
+      "  body { margin: 0 }"
+      "  #container { width: 200px; height: 200px;"
+      "              overflow: scroll; background: transparent;"
+      "              position: relative; z-index: auto; }"
+      "  #child { width: 80px; height: 20px; background: white; }"
+      "  #negZChild { width: 60px; height: 300px; background: purple;"
+      "               position: absolute; z-index: -1; top: 0; }"
+      "  #posZChild { width: 40px; height: 300px; background: yellow;"
+      "               position: absolute; z-index: 1; top: 0; }"
+      "</style>"
+      "<div id='container'>"
+      "  <div id='child'></div>"
+      "  <div id='negZChild'></div>"
+      "  <div id='posZChild'></div>"
+      "</div>");
+
+  auto& container = *ToLayoutBlock(GetLayoutObjectByElementId("container"));
+  auto& child = *GetLayoutObjectByElementId("child");
+  auto& neg_z_child = *GetLayoutObjectByElementId("negZChild");
+  auto& pos_z_child = *GetLayoutObjectByElementId("posZChild");
+
+  // Even though container does not paint a background, the scroll hit test item
+  // should still be between the negative z-index child and the regular child.
+  EXPECT_DISPLAY_LIST(RootPaintController().GetDisplayItemList(), 5,
+                      TestDisplayItem(GetLayoutView(), kDocumentBackgroundType),
+                      TestDisplayItem(neg_z_child, kBackgroundType),
+                      TestDisplayItem(container, kScrollHitTestType),
+                      TestDisplayItem(child, kBackgroundType),
+                      TestDisplayItem(pos_z_child, kBackgroundType));
+}
+
 }  // namespace blink

third_party/WebKit/Source/core/paint/PaintControllerPaintTest.h

diff --git a/third_party/WebKit/Source/core/paint/PaintControllerPaintTest.h b/third_party/WebKit/Source/core/paint/PaintControllerPaintTest.h
index f7dde2a..453e014 100644
--- a/third_party/WebKit/Source/core/paint/PaintControllerPaintTest.h
+++ b/third_party/WebKit/Source/core/paint/PaintControllerPaintTest.h
@@ -150,6 +150,7 @@
     DisplayItem::PaintPhaseToDrawingType(kPaintPhaseForeground);
 const DisplayItem::Type kDocumentBackgroundType =
     DisplayItem::kDocumentBackground;
+const DisplayItem::Type kScrollHitTestType = DisplayItem::kScrollHitTest;
 
 }  // namespace blink
 

third_party/WebKit/Source/devtools/front_end/audits/AuditExtensionCategory.js

diff --git a/third_party/WebKit/Source/devtools/front_end/audits/AuditExtensionCategory.js b/third_party/WebKit/Source/devtools/front_end/audits/AuditExtensionCategory.js
index 2a7b989..e0d2687 100644
--- a/third_party/WebKit/Source/devtools/front_end/audits/AuditExtensionCategory.js
+++ b/third_party/WebKit/Source/devtools/front_end/audits/AuditExtensionCategory.js
@@ -163,22 +163,18 @@
   evaluate(expression, evaluateOptions, callback) {
     /**
      * @param {?string} error
-     * @param {!Protocol.Runtime.RemoteObject} result
+     * @param {?SDK.RemoteObject} result
      * @param {boolean=} wasThrown
      * @this {Audits.AuditExtensionCategoryResults}
      */
     function onEvaluate(error, result, wasThrown) {
       var runtimeModel = this._target.model(SDK.RuntimeModel);
-      if (wasThrown || !runtimeModel)
+      if (wasThrown || !runtimeModel || !result)
         return;
-      var object = runtimeModel.createRemoteObject(result);
-      callback(object);
+      callback(result);
     }
-
-    var evaluateCallback =
-        /** @type {function(?string, ?SDK.RemoteObject, boolean=)} */ (onEvaluate.bind(this));
     Extensions.extensionServer.evaluate(
-        expression, false, false, evaluateOptions, this._category._extensionOrigin, evaluateCallback);
+        expression, false, false, evaluateOptions, this._category._extensionOrigin, onEvaluate.bind(this));
   }
 };
 

third_party/WebKit/Source/devtools/front_end/audits2/Audits2Panel.js

diff --git a/third_party/WebKit/Source/devtools/front_end/audits2/Audits2Panel.js b/third_party/WebKit/Source/devtools/front_end/audits2/Audits2Panel.js
index 41a3f34..cedf78a8c 100644
--- a/third_party/WebKit/Source/devtools/front_end/audits2/Audits2Panel.js
+++ b/third_party/WebKit/Source/devtools/front_end/audits2/Audits2Panel.js
@@ -248,16 +248,23 @@
 
     // Evaluate location.href for a more specific URL than inspectedURL provides so that SPA hash navigation routes
     // will be respected and audited.
-    return new Promise(resolve => {
-      executionContext.evaluate('window.location.href', 'audits', false, false, true, false, false, (object, err) => {
-        if (!err && object) {
-          this._inspectedURL = object.value;
-          object.release();
-        }
-
-        resolve();
-      });
-    });
+    return executionContext
+        .evaluate(
+            {
+              expression: 'window.location.href',
+              objectGroup: 'audits',
+              includeCommandLineAPI: false,
+              silent: false,
+              returnByValue: true,
+              generatePreview: false
+            },
+            /* userGesture */ false, /* awaitPromise */ false)
+        .then(result => {
+          if (!result.exceptionDetails && result.object) {
+            this._inspectedURL = result.object.value;
+            result.object.release();
+          }
+        });
   }
 
   _start() {

third_party/WebKit/Source/devtools/front_end/console/ConsolePrompt.js

diff --git a/third_party/WebKit/Source/devtools/front_end/console/ConsolePrompt.js b/third_party/WebKit/Source/devtools/front_end/console/ConsolePrompt.js
index e3ec4f24..2aa72e8 100644
--- a/third_party/WebKit/Source/devtools/front_end/console/ConsolePrompt.js
+++ b/third_party/WebKit/Source/devtools/front_end/console/ConsolePrompt.js
@@ -152,7 +152,7 @@
   /**
    * @param {!KeyboardEvent} event
    */
-  _enterKeyPressed(event) {
+  async _enterKeyPressed(event) {
     if (event.altKey || event.ctrlKey || event.shiftKey)
       return;
 
@@ -169,27 +169,19 @@
       this._appendCommand(str, true);
       return;
     }
-    currentExecutionContext.runtimeModel.compileScript(
-        str, '', false, currentExecutionContext.id, compileCallback.bind(this));
-
-    /**
-     * @param {!Protocol.Runtime.ScriptId=} scriptId
-     * @param {?Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     * @this {Console.ConsolePrompt}
-     */
-    function compileCallback(scriptId, exceptionDetails) {
-      if (str !== this.text())
-        return;
-      if (exceptionDetails &&
-          (exceptionDetails.exception.description.startsWith('SyntaxError: Unexpected end of input') ||
-           exceptionDetails.exception.description.startsWith('SyntaxError: Unterminated template literal'))) {
-        this._editor.newlineAndIndent();
-        this._enterProcessedForTest();
-        return;
-      }
-      this._appendCommand(str, true);
+    var result = await currentExecutionContext.runtimeModel.compileScript(str, '', false, currentExecutionContext.id);
+    if (str !== this.text())
+      return;
+    var exceptionDetails = result.exceptionDetails;
+    if (exceptionDetails &&
+        (exceptionDetails.exception.description.startsWith('SyntaxError: Unexpected end of input') ||
+         exceptionDetails.exception.description.startsWith('SyntaxError: Unterminated template literal'))) {
+      this._editor.newlineAndIndent();
       this._enterProcessedForTest();
+      return;
     }
+    this._appendCommand(str, true);
+    this._enterProcessedForTest();
   }
 
   /**

third_party/WebKit/Source/devtools/front_end/console/ConsoleView.js

diff --git a/third_party/WebKit/Source/devtools/front_end/console/ConsoleView.js b/third_party/WebKit/Source/devtools/front_end/console/ConsoleView.js
index 09963dae..1fbb94bf 100644
--- a/third_party/WebKit/Source/devtools/front_end/console/ConsoleView.js
+++ b/third_party/WebKit/Source/devtools/front_end/console/ConsoleView.js
@@ -775,9 +775,9 @@
    */
   _commandEvaluated(event) {
     var data =
-        /** @type {{result: ?SDK.RemoteObject, text: string, commandMessage: !ConsoleModel.ConsoleMessage, exceptionDetails: (!Protocol.Runtime.ExceptionDetails|undefined)}} */
+        /** @type {{result: ?SDK.RemoteObject, commandMessage: !ConsoleModel.ConsoleMessage, exceptionDetails: (!Protocol.Runtime.ExceptionDetails|undefined)}} */
         (event.data);
-    this._prompt.history().pushHistoryItem(data.text);
+    this._prompt.history().pushHistoryItem(data.commandMessage.messageText);
     this._consoleHistorySetting.set(
         this._prompt.history().historyData().slice(-Console.ConsoleView.persistedHistorySize));
     this._printResult(data.result, data.commandMessage, data.exceptionDetails);

third_party/WebKit/Source/devtools/front_end/console_model/ConsoleModel.js

diff --git a/third_party/WebKit/Source/devtools/front_end/console_model/ConsoleModel.js b/third_party/WebKit/Source/devtools/front_end/console_model/ConsoleModel.js
index 369f4ff..13e5fc0 100644
--- a/third_party/WebKit/Source/devtools/front_end/console_model/ConsoleModel.js
+++ b/third_party/WebKit/Source/devtools/front_end/console_model/ConsoleModel.js
@@ -124,33 +124,30 @@
    * @param {string} text
    * @param {boolean} useCommandLineAPI
    */
-  evaluateCommandInConsole(executionContext, text, useCommandLineAPI) {
-    var requestedText = text;
+  async evaluateCommandInConsole(executionContext, text, useCommandLineAPI) {
     var commandMessage = new ConsoleModel.ConsoleMessage(
         executionContext.runtimeModel, ConsoleModel.ConsoleMessage.MessageSource.JS, null, text,
         ConsoleModel.ConsoleMessage.MessageType.Command);
     commandMessage.setExecutionContextId(executionContext.id);
     this.addMessage(commandMessage);
 
-    /**
-     * @param {?SDK.RemoteObject} result
-     * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     * @this {ConsoleModel.ConsoleModel}
-     */
-    function printResult(result, exceptionDetails) {
-      if (!result)
-        return;
-
-      Common.console.showPromise().then(() => {
-        this.dispatchEventToListeners(
-            ConsoleModel.ConsoleModel.Events.CommandEvaluated,
-            {result: result, text: requestedText, commandMessage: commandMessage, exceptionDetails: exceptionDetails});
-      });
-    }
-
-    text = SDK.RuntimeModel.wrapObjectLiteralExpressionIfNeeded(text);
-    executionContext.evaluate(text, 'console', useCommandLineAPI, false, false, true, true, printResult.bind(this));
+    var result = await executionContext.evaluate(
+        {
+          expression: SDK.RuntimeModel.wrapObjectLiteralExpressionIfNeeded(text),
+          objectGroup: 'console',
+          includeCommandLineAPI: useCommandLineAPI,
+          silent: false,
+          returnByValue: false,
+          generatePreview: true
+        },
+        /* userGesture */ true, /* awaitPromise */ false);
     Host.userMetrics.actionTaken(Host.UserMetrics.Action.ConsoleEvaluated);
+    if (result.error)
+      return;
+    await Common.console.showPromise();
+    this.dispatchEventToListeners(
+        ConsoleModel.ConsoleModel.Events.CommandEvaluated,
+        {result: result.object, commandMessage: commandMessage, exceptionDetails: result.exceptionDetails});
   }
 
   /**

third_party/WebKit/Source/devtools/front_end/elements/EventListenersWidget.js

diff --git a/third_party/WebKit/Source/devtools/front_end/elements/EventListenersWidget.js b/third_party/WebKit/Source/devtools/front_end/elements/EventListenersWidget.js
index 668d797..72d10cb 100644
--- a/third_party/WebKit/Source/devtools/front_end/elements/EventListenersWidget.js
+++ b/third_party/WebKit/Source/devtools/front_end/elements/EventListenersWidget.js
@@ -141,30 +141,33 @@
 
   /**
    * @param {!SDK.DOMNode} node
-   * @return {!Promise<!SDK.RemoteObject>}
+   * @return {!Promise<?SDK.RemoteObject>}
    */
   _windowObjectInNodeContext(node) {
-    return new Promise(windowObjectInNodeContext);
-
-    /**
-     * @param {function(?)} fulfill
-     * @param {function(*)} reject
-     */
-    function windowObjectInNodeContext(fulfill, reject) {
-      var executionContexts = node.domModel().runtimeModel().executionContexts();
-      var context = null;
-      if (node.frameId()) {
-        for (var i = 0; i < executionContexts.length; ++i) {
-          var executionContext = executionContexts[i];
-          if (executionContext.frameId === node.frameId() && executionContext.isDefault)
-            context = executionContext;
-        }
-      } else {
-        context = executionContexts[0];
+    var executionContexts = node.domModel().runtimeModel().executionContexts();
+    var context = null;
+    if (node.frameId()) {
+      for (var i = 0; i < executionContexts.length; ++i) {
+        var executionContext = executionContexts[i];
+        if (executionContext.frameId === node.frameId() && executionContext.isDefault)
+          context = executionContext;
       }
-      context.evaluate(
-          'self', Elements.EventListenersWidget._objectGroupName, false, true, false, false, false, fulfill);
+    } else {
+      context = executionContexts[0];
     }
+    return context
+        .evaluate(
+            {
+              expression: 'self',
+              objectGroup: Elements.EventListenersWidget._objectGroupName,
+              includeCommandLineAPI: false,
+              silent: true,
+              returnByValue: false,
+              generatePreview: false
+            },
+            /* userGesture */ false,
+            /* awaitPromise */ false)
+        .then(result => result.object || null);
   }
 
   _eventListenersArrivedForTest() {

third_party/WebKit/Source/devtools/front_end/event_listeners/EventListenersView.js

diff --git a/third_party/WebKit/Source/devtools/front_end/event_listeners/EventListenersView.js b/third_party/WebKit/Source/devtools/front_end/event_listeners/EventListenersView.js
index e35dd93..91e680f 100644
--- a/third_party/WebKit/Source/devtools/front_end/event_listeners/EventListenersView.js
+++ b/third_party/WebKit/Source/devtools/front_end/event_listeners/EventListenersView.js
@@ -31,17 +31,14 @@
   }
 
   /**
-   * @param {!Array<!SDK.RemoteObject>} objects
+   * @param {!Array<?SDK.RemoteObject>} objects
    * @return {!Promise<undefined>}
    */
-  addObjects(objects) {
+  async addObjects(objects) {
     this.reset();
-    var promises = [];
-    for (var object of objects)
-      promises.push(this._addObject(object));
-    return Promise.all(promises)
-        .then(this.addEmptyHolderIfNeeded.bind(this))
-        .then(this._eventListenersArrivedForTest.bind(this));
+    await Promise.all(objects.map(obj => obj ? this._addObject(obj) : Promise.resolve()));
+    this.addEmptyHolderIfNeeded();
+    this._eventListenersArrivedForTest();
   }
 
   /**

third_party/WebKit/Source/devtools/front_end/extensions/ExtensionPanel.js

diff --git a/third_party/WebKit/Source/devtools/front_end/extensions/ExtensionPanel.js b/third_party/WebKit/Source/devtools/front_end/extensions/ExtensionPanel.js
index d5bef57..488094f 100644
--- a/third_party/WebKit/Source/devtools/front_end/extensions/ExtensionPanel.js
+++ b/third_party/WebKit/Source/devtools/front_end/extensions/ExtensionPanel.js
@@ -248,10 +248,10 @@
    * @param {boolean=} wasThrown
    */
   _onEvaluate(title, callback, error, result, wasThrown) {
-    if (error)
+    if (error || !result)
       callback(error.toString());
     else
-      this._setObject(/** @type {!SDK.RemoteObject} */ (result), title, callback);
+      this._setObject(result, title, callback);
   }
 
   _createObjectPropertiesView() {

third_party/WebKit/Source/devtools/front_end/extensions/ExtensionServer.js

diff --git a/third_party/WebKit/Source/devtools/front_end/extensions/ExtensionServer.js b/third_party/WebKit/Source/devtools/front_end/extensions/ExtensionServer.js
index 9c9d2e7..97a0a59 100644
--- a/third_party/WebKit/Source/devtools/front_end/extensions/ExtensionServer.js
+++ b/third_party/WebKit/Source/devtools/front_end/extensions/ExtensionServer.js
@@ -429,18 +429,18 @@
   _onEvaluateOnInspectedPage(message, port) {
     /**
      * @param {?Protocol.Error} error
-     * @param {?SDK.RemoteObject} remoteObject
-     * @param {boolean=} wasThrown
+     * @param {?SDK.RemoteObject} object
+     * @param {boolean} wasThrown
      * @this {Extensions.ExtensionServer}
      */
-    function callback(error, remoteObject, wasThrown) {
+    function callback(error, object, wasThrown) {
       var result;
-      if (error || !remoteObject)
+      if (error || !object)
         result = this._status.E_PROTOCOLERROR(error.toString());
       else if (wasThrown)
-        result = {isException: true, value: remoteObject.description};
+        result = {isException: true, value: object.description};
       else
-        result = {value: remoteObject.value};
+        result = {value: object.value};
 
       this._dispatchCallback(message.requestId, port, result);
     }
@@ -888,7 +888,7 @@
    * @param {boolean} returnByValue
    * @param {?Object} options
    * @param {string} securityOrigin
-   * @param {function(?string, ?SDK.RemoteObject, boolean=)} callback
+   * @param {function(?string, ?SDK.RemoteObject, boolean)} callback
    * @return {!Extensions.ExtensionStatus.Record|undefined}
    */
   evaluate(expression, exposeCommandLineAPI, returnByValue, options, securityOrigin, callback) {
@@ -954,19 +954,28 @@
         return this._status.E_FAILED(frame.url + ' has no execution context');
     }
 
-    context.evaluate(expression, 'extension', exposeCommandLineAPI, true, returnByValue, false, false, onEvaluate);
+    context
+        .evaluate(
+            {
+              expression: expression,
+              objectGroup: 'extension',
+              includeCommandLineAPI: exposeCommandLineAPI,
+              silent: true,
+              returnByValue: returnByValue,
+              generatePreview: false
+            },
+            /* userGesture */ false, /* awaitPromise */ false)
+        .then(onEvaluate);
 
     /**
-     * @param {?SDK.RemoteObject} result
-     * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     * @param {string=} error
+     * @param {!SDK.RuntimeModel.EvaluationResult} result
      */
-    function onEvaluate(result, exceptionDetails, error) {
-      if (error) {
-        callback(error, null, !!exceptionDetails);
+    function onEvaluate(result) {
+      if (result.error) {
+        callback(result.error, null, false);
         return;
       }
-      callback(null, result, !!exceptionDetails);
+      callback(null, result.object || null, !!result.exceptionDetails);
     }
   }
 };

third_party/WebKit/Source/devtools/front_end/integration_test_runner/IntegrationTestRunner.js

diff --git a/third_party/WebKit/Source/devtools/front_end/integration_test_runner/IntegrationTestRunner.js b/third_party/WebKit/Source/devtools/front_end/integration_test_runner/IntegrationTestRunner.js
index 412f2a23..8c7901b 100644
--- a/third_party/WebKit/Source/devtools/front_end/integration_test_runner/IntegrationTestRunner.js
+++ b/third_party/WebKit/Source/devtools/front_end/integration_test_runner/IntegrationTestRunner.js
@@ -110,7 +110,18 @@
 TestRunner.evaluateFunctionInOverlay = function(func, callback) {
   var expression = 'testRunner.evaluateInWebInspectorOverlay("(" + ' + func + ' + ")()")';
   var mainContext = TestRunner.runtimeModel.executionContexts()[0];
-  mainContext.evaluate(expression, '', false, false, true, false, false, result => void callback(result.value));
+  mainContext
+      .evaluate(
+          {
+            expression: expression,
+            objectGroup: '',
+            includeCommandLineAPI: false,
+            silent: false,
+            returnByValue: true,
+            generatePreview: false
+          },
+          /* userGesture */ false, /* awaitPromise*/ false)
+      .then(result => void callback(result.object.value));
 };
 
 /**

third_party/WebKit/Source/devtools/front_end/object_ui/JavaScriptAutocomplete.js

diff --git a/third_party/WebKit/Source/devtools/front_end/object_ui/JavaScriptAutocomplete.js b/third_party/WebKit/Source/devtools/front_end/object_ui/JavaScriptAutocomplete.js
index 04ed56f..52d771b 100644
--- a/third_party/WebKit/Source/devtools/front_end/object_ui/JavaScriptAutocomplete.js
+++ b/third_party/WebKit/Source/devtools/front_end/object_ui/JavaScriptAutocomplete.js
@@ -61,42 +61,32 @@
  * @param {string} query
  * @return {!Promise<!UI.SuggestBox.Suggestions>}
  */
-ObjectUI.JavaScriptAutocomplete._mapCompletions = function(text, query) {
+ObjectUI.JavaScriptAutocomplete._mapCompletions = async function(text, query) {
   var mapMatch = text.match(/\.\s*(get|set|delete)\s*\(\s*$/);
   var executionContext = UI.context.flavor(SDK.ExecutionContext);
   if (!executionContext || !mapMatch)
-    return Promise.resolve([]);
+    return [];
 
   var clippedExpression = ObjectUI.JavaScriptAutocomplete._clipExpression(text.substring(0, mapMatch.index));
-  var fulfill;
-  var promise = new Promise(x => fulfill = x);
-  executionContext.evaluate(clippedExpression, 'completion', true, true, false, false, false, evaluated);
-  return promise;
-
-  /**
-   * @param {?SDK.RemoteObject} result
-   * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
-   */
-  function evaluated(result, exceptionDetails) {
-    if (!result || !!exceptionDetails || result.subtype !== 'map') {
-      fulfill([]);
-      return;
-    }
-    result.getOwnPropertiesPromise(false).then(extractEntriesProperty);
-  }
-
-  /**
-   * @param {!{properties: ?Array<!SDK.RemoteObjectProperty>, internalProperties: ?Array<!SDK.RemoteObjectProperty>}} properties
-   */
-  function extractEntriesProperty(properties) {
-    var internalProperties = properties.internalProperties || [];
-    var entriesProperty = internalProperties.find(property => property.name === '[[Entries]]');
-    if (!entriesProperty) {
-      fulfill([]);
-      return;
-    }
-    entriesProperty.value.callFunctionJSONPromise(getEntries).then(keysObj => gotKeys(Object.keys(keysObj)));
-  }
+  var result = await executionContext.evaluate(
+      {
+        expression: clippedExpression,
+        objectGroup: 'completion',
+        includeCommandLineAPI: true,
+        silent: true,
+        returnByValue: false,
+        generatePreview: false
+      },
+      /* userGesture */ false, /* awaitPromise */ false);
+  if (result.error || !!result.exceptionDetails || result.object.subtype !== 'map')
+    return [];
+  var properties = await result.object.getOwnPropertiesPromise(false);
+  var internalProperties = properties.internalProperties || [];
+  var entriesProperty = internalProperties.find(property => property.name === '[[Entries]]');
+  if (!entriesProperty)
+    return [];
+  var keysObj = await entriesProperty.value.callFunctionJSONPromise(getEntries);
+  return gotKeys(Object.keys(keysObj));
 
   /**
    * @suppressReceiverCheck
@@ -114,6 +104,7 @@
 
   /**
    * @param {!Array<string>} rawKeys
+   * @return {!UI.SuggestBox.Suggestions}
    */
   function gotKeys(rawKeys) {
     var caseSensitivePrefix = [];
@@ -151,7 +142,7 @@
     var suggestions = caseSensitivePrefix.concat(caseInsensitivePrefix, caseSensitiveAnywhere, caseInsensitiveAnywhere);
     if (suggestions.length)
       suggestions[0].subtitle = Common.UIString('Keys');
-    fulfill(suggestions);
+    return suggestions;
   }
 };
 
@@ -161,10 +152,10 @@
  * @param {boolean=} force
  * @return {!Promise<!UI.SuggestBox.Suggestions>}
  */
-ObjectUI.JavaScriptAutocomplete.completionsForExpression = function(expressionString, query, force) {
+ObjectUI.JavaScriptAutocomplete.completionsForExpression = async function(expressionString, query, force) {
   var executionContext = UI.context.flavor(SDK.ExecutionContext);
   if (!executionContext)
-    return Promise.resolve([]);
+    return [];
 
   var lastIndex = expressionString.length - 1;
 
@@ -178,54 +169,67 @@
 
   // User is entering float value, do not suggest anything.
   if ((expressionString && !isNaN(expressionString)) || (!expressionString && query && !isNaN(query)))
-    return Promise.resolve([]);
+    return [];
 
 
   if (!query && !expressionString && !force)
-    return Promise.resolve([]);
-
-  var fulfill;
-  var promise = new Promise(x => fulfill = x);
+    return [];
   var selectedFrame = executionContext.debuggerModel.selectedCallFrame();
-  if (!expressionString && selectedFrame)
-    variableNamesInScopes(selectedFrame, receivedPropertyNames);
-  else
-    executionContext.evaluate(expressionString, 'completion', true, true, false, false, false, evaluated);
+  if (!expressionString && selectedFrame) {
+    return completionsOnPause(selectedFrame);
+  } else {
+    var result = await executionContext.evaluate(
+        {
+          expression: expressionString,
+          objectGroup: 'completion',
+          includeCommandLineAPI: true,
+          silent: true,
+          returnByValue: false,
+          generatePreview: false
+        },
+        /* userGesture */ false, /* awaitPromise */ false);
+    return completionsOnGlobal(result);
+  }
 
-  return promise;
   /**
-   * @param {?SDK.RemoteObject} result
-   * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
+   * @param {!SDK.RuntimeModel.EvaluationResult} result
+   * @return {!Promise<!UI.SuggestBox.Suggestions>}
    */
-  function evaluated(result, exceptionDetails) {
-    if (!result || !!exceptionDetails) {
-      fulfill([]);
-      return;
-    }
+  async function completionsOnGlobal(result) {
+    if (result.error || !!result.exceptionDetails || !result.object)
+      return [];
 
-    /**
-     * @param {?SDK.RemoteObject} object
-     * @return {!Promise<?SDK.RemoteObject>}
-     */
-    function extractTarget(object) {
-      if (!object)
-        return Promise.resolve(/** @type {?SDK.RemoteObject} */ (null));
-      if (object.type !== 'object' || object.subtype !== 'proxy')
-        return Promise.resolve(/** @type {?SDK.RemoteObject} */ (object));
-      return object.getOwnPropertiesPromise(false /* generatePreview */)
-          .then(extractTargetFromProperties)
-          .then(extractTarget);
-    }
-
-    /**
-     * @param {!{properties: ?Array<!SDK.RemoteObjectProperty>, internalProperties: ?Array<!SDK.RemoteObjectProperty>}} properties
-     * @return {?SDK.RemoteObject}
-     */
-    function extractTargetFromProperties(properties) {
+    var object = result.object;
+    while (object && object.type === 'object' && object.subtype === 'proxy') {
+      var properties = await object.getOwnPropertiesPromise(false /* generatePreview */);
       var internalProperties = properties.internalProperties || [];
       var target = internalProperties.find(property => property.name === '[[Target]]');
-      return target ? target.value : null;
+      object = target ? target.value : null;
     }
+    if (!object)
+      return [];
+    var completions = [];
+    if (object.type === 'object' || object.type === 'function') {
+      completions =
+          await object.callFunctionJSONPromise(getCompletions, [SDK.RemoteObject.toCallArgument(object.subtype)]);
+    } else if (object.type === 'string' || object.type === 'number' || object.type === 'boolean') {
+      var evaluateResult = await executionContext.evaluate(
+          {
+            expression: '(' + getCompletions + ')("' + object.type + '")',
+            objectGroup: 'completion',
+            includeCommandLineAPI: false,
+            silent: true,
+            returnByValue: true,
+            generatePreview: false
+          },
+          /* userGesture */ false,
+          /* awaitPromise */ false);
+      if (evaluateResult.object && !evaluateResult.exceptionDetails)
+        completions = evaluateResult.object.value;
+    }
+    executionContext.runtimeModel.releaseObjectGroup('completion');
+    return receivedPropertyNames(completions);
+
 
     /**
      * @param {string=} type
@@ -271,79 +275,36 @@
       }
       return result;
     }
-
-    /**
-     * @param {?SDK.RemoteObject} object
-     */
-    function completionsForObject(object) {
-      if (!object) {
-        receivedPropertyNames(null);
-      } else if (object.type === 'object' || object.type === 'function') {
-        object.callFunctionJSON(
-            getCompletions, [SDK.RemoteObject.toCallArgument(object.subtype)], receivedPropertyNames);
-      } else if (object.type === 'string' || object.type === 'number' || object.type === 'boolean') {
-        executionContext.evaluate(
-            '(' + getCompletions + ')("' + result.type + '")', 'completion', false, true, true, false, false,
-            receivedPropertyNamesFromEval);
-      }
-    }
-
-    extractTarget(result).then(completionsForObject);
   }
 
   /**
    * @param {!SDK.DebuggerModel.CallFrame} callFrame
-   * @param {function(!Array<!ObjectUI.JavaScriptAutocomplete.CompletionGroup>)} callback
+   * @return {!Promise<!UI.SuggestBox.Suggestions>}
    */
-  function variableNamesInScopes(callFrame, callback) {
+  async function completionsOnPause(callFrame) {
     var result = [{items: ['this']}];
-
-    /**
-     * @param {string} name
-     * @param {?Array<!SDK.RemoteObjectProperty>} properties
-     */
-    function propertiesCollected(name, properties) {
-      var group = {title: name, items: []};
-      result.push(group);
-      for (var i = 0; properties && i < properties.length; ++i)
-        group.items.push(properties[i].name);
-      if (--pendingRequests === 0)
-        callback(result);
-    }
-
     var scopeChain = callFrame.scopeChain();
-    var pendingRequests = scopeChain.length;
-    for (var i = 0; i < scopeChain.length; ++i) {
-      var scope = scopeChain[i];
-      var object = scope.object();
-      object.getAllProperties(
-          false /* accessorPropertiesOnly */, false /* generatePreview */,
-          propertiesCollected.bind(null, scope.typeName()));
+    var groupPromises = [];
+    for (var scope of scopeChain) {
+      groupPromises.push(scope.object()
+                             .getAllPropertiesPromise(false /* accessorPropertiesOnly */, false /* generatePreview */)
+                             .then(result => ({properties: result.properties, name: scope.name()})));
     }
+    var fullScopes = await Promise.all(groupPromises);
+    executionContext.runtimeModel.releaseObjectGroup('completion');
+    for (var scope of fullScopes)
+      result.push({title: scope.name, items: scope.properties.map(property => property.name)});
+    return receivedPropertyNames(result);
   }
 
   /**
-   * @param {?SDK.RemoteObject} result
-   * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
+   * @param {?Object} completions
+   * @return {!UI.SuggestBox.Suggestions}
    */
-  function receivedPropertyNamesFromEval(result, exceptionDetails) {
-    executionContext.runtimeModel.releaseObjectGroup('completion');
-    if (result && !exceptionDetails)
-      receivedPropertyNames(/** @type {!Object} */ (result.value));
-    else
-      fulfill([]);
-  }
-
-  /**
-   * @param {?Object} object
-   */
-  function receivedPropertyNames(object) {
-    executionContext.runtimeModel.releaseObjectGroup('completion');
-    if (!object) {
-      fulfill([]);
-      return;
-    }
-    var propertyGroups = /** @type {!Array<!ObjectUI.JavaScriptAutocomplete.CompletionGroup>} */ (object);
+  function receivedPropertyNames(completions) {
+    if (!completions)
+      return [];
+    var propertyGroups = /** @type {!Array<!ObjectUI.JavaScriptAutocomplete.CompletionGroup>} */ (completions);
     var includeCommandLineAPI = (!dotNotation && !bracketNotation);
     if (includeCommandLineAPI) {
       const commandLineAPI = [
@@ -370,8 +331,8 @@
       ];
       propertyGroups.push({items: commandLineAPI});
     }
-    fulfill(ObjectUI.JavaScriptAutocomplete._completionsForQuery(
-        dotNotation, bracketNotation, expressionString, query, propertyGroups));
+    return ObjectUI.JavaScriptAutocomplete._completionsForQuery(
+        dotNotation, bracketNotation, expressionString, query, propertyGroups);
   }
 };
 

third_party/WebKit/Source/devtools/front_end/sdk/DebuggerModel.js

diff --git a/third_party/WebKit/Source/devtools/front_end/sdk/DebuggerModel.js b/third_party/WebKit/Source/devtools/front_end/sdk/DebuggerModel.js
index 38989116..602faf5 100644
--- a/third_party/WebKit/Source/devtools/front_end/sdk/DebuggerModel.js
+++ b/third_party/WebKit/Source/devtools/front_end/sdk/DebuggerModel.js
@@ -683,37 +683,11 @@
   }
 
   /**
-   * @param {string} code
-   * @param {string} objectGroup
-   * @param {boolean} includeCommandLineAPI
-   * @param {boolean} silent
-   * @param {boolean} returnByValue
-   * @param {boolean} generatePreview
-   * @param {function(?SDK.RemoteObject, !Protocol.Runtime.ExceptionDetails=, string=)} callback
+   * @param {!SDK.RuntimeModel.EvaluationOptions} options
+   * @return {!Promise<!SDK.RuntimeModel.EvaluationResult>}
    */
-  evaluateOnSelectedCallFrame(
-      code,
-      objectGroup,
-      includeCommandLineAPI,
-      silent,
-      returnByValue,
-      generatePreview,
-      callback) {
-    /**
-     * @param {?Protocol.Runtime.RemoteObject} result
-     * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     * @param {string=} error
-     * @this {SDK.DebuggerModel}
-     */
-    function didEvaluate(result, exceptionDetails, error) {
-      if (!result)
-        callback(null, undefined, error);
-      else
-        callback(this._runtimeModel.createRemoteObject(result), exceptionDetails);
-    }
-
-    this.selectedCallFrame().evaluate(
-        code, objectGroup, includeCommandLineAPI, silent, returnByValue, generatePreview, didEvaluate.bind(this));
+  evaluateOnSelectedCallFrame(options) {
+    return this.selectedCallFrame().evaluate(options);
   }
 
   /**
@@ -1200,61 +1174,29 @@
   }
 
   /**
-   * @param {string} code
-   * @param {string} objectGroup
-   * @param {boolean} includeCommandLineAPI
-   * @param {boolean} silent
-   * @param {boolean} returnByValue
-   * @param {boolean} generatePreview
-   * @param {function(?Protocol.Runtime.RemoteObject, !Protocol.Runtime.ExceptionDetails=, string=)} callback
+   * @param {!SDK.RuntimeModel.EvaluationOptions} options
+   * @return {!Promise<!SDK.RuntimeModel.EvaluationResult>}
    */
-  async evaluate(code, objectGroup, includeCommandLineAPI, silent, returnByValue, generatePreview, callback) {
+  async evaluate(options) {
     var response = await this.debuggerModel._agent.invoke_evaluateOnCallFrame({
-      callFrameId: this._payload.callFrameId,
-      expression: code,
-      objectGroup: objectGroup,
-      includeCommandLineAPI: includeCommandLineAPI,
-      silent: silent,
-      returnByValue: returnByValue,
-      generatePreview: generatePreview
+      callFrameId: this.id,
+      expression: options.expression,
+      objectGroup: options.objectGroup,
+      includeCommandLineAPI: options.includeCommandLineAPI,
+      silent: options.silent,
+      returnByValue: options.returnByValue,
+      generatePreview: options.generatePreview,
+      throwOnSideEffect: false
     });
     var error = response[Protocol.Error];
     if (error) {
       console.error(error);
-      callback(null, undefined, error);
-      return;
+      return {error: error};
     }
-    callback(response.result, response.exceptionDetails);
-  }
-
-  /**
-   * @param {string} code
-   * @param {string} objectGroup
-   * @param {boolean} includeCommandLineAPI
-   * @param {boolean} silent
-   * @param {boolean} returnByValue
-   * @param {boolean} generatePreview
-   * @return {!Promise<?SDK.RemoteObject>}
-   */
-  evaluatePromise(code, objectGroup, includeCommandLineAPI, silent, returnByValue, generatePreview) {
-    var fulfill;
-    var promise = new Promise(x => fulfill = x);
-    this.evaluate(
-        code, objectGroup, includeCommandLineAPI, silent, returnByValue, generatePreview, callback.bind(this));
-    return promise;
-
-    /**
-     * @param {?Protocol.Runtime.RemoteObject} result
-     * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     * @param {string=} error
-     * @this {SDK.DebuggerModel.CallFrame}
-     */
-    function callback(result, exceptionDetails, error) {
-      if (!result || exceptionDetails)
-        fulfill(null);
-      else
-        fulfill(this.debuggerModel._runtimeModel.createRemoteObject(result));
-    }
+    return {
+      object: this.debuggerModel.runtimeModel().createRemoteObject(response.result),
+      exceptionDetails: response.exceptionDetails
+    };
   }
 
   async restart() {

third_party/WebKit/Source/devtools/front_end/sdk/RuntimeModel.js

diff --git a/third_party/WebKit/Source/devtools/front_end/sdk/RuntimeModel.js b/third_party/WebKit/Source/devtools/front_end/sdk/RuntimeModel.js
index 7f762984..338eab4 100644
--- a/third_party/WebKit/Source/devtools/front_end/sdk/RuntimeModel.js
+++ b/third_party/WebKit/Source/devtools/front_end/sdk/RuntimeModel.js
@@ -245,9 +245,9 @@
    * @param {string} sourceURL
    * @param {boolean} persistScript
    * @param {number} executionContextId
-   * @param {function(!Protocol.Runtime.ScriptId=, ?Protocol.Runtime.ExceptionDetails=)=} callback
+   * @return {?Promise<!SDK.RuntimeModel.CompileScriptResult>}
    */
-  async compileScript(expression, sourceURL, persistScript, executionContextId, callback) {
+  async compileScript(expression, sourceURL, persistScript, executionContextId) {
     var response = await this._agent.invoke_compileScript({
       expression: expression,
       sourceURL: sourceURL,
@@ -257,10 +257,9 @@
 
     if (response[Protocol.Error]) {
       console.error(response[Protocol.Error]);
-      return;
+      return null;
     }
-    if (callback)
-      callback(response.scriptId, response.exceptionDetails);
+    return {scriptId: response.scriptId, exceptionDetails: response.exceptionDetails};
   }
 
   /**
@@ -272,11 +271,11 @@
    * @param {boolean=} returnByValue
    * @param {boolean=} generatePreview
    * @param {boolean=} awaitPromise
-   * @param {function(?Protocol.Runtime.RemoteObject, ?Protocol.Runtime.ExceptionDetails=)=} callback
+   * @return {!Promise<!SDK.RuntimeModel.EvaluationResult>}
    */
   async runScript(
       scriptId, executionContextId, objectGroup, silent, includeCommandLineAPI, returnByValue, generatePreview,
-      awaitPromise, callback) {
+      awaitPromise) {
     var response = await this._agent.invoke_runScript({
       scriptId,
       executionContextId,
@@ -288,12 +287,12 @@
       awaitPromise
     });
 
-    if (response[Protocol.Error]) {
-      console.error(response[Protocol.Error]);
-      return;
+    var error = response[Protocol.Error];
+    if (error) {
+      console.error(error);
+      return {error: error};
     }
-    if (callback)
-      callback(response.result, response.exceptionDetails);
+    return {object: this.createRemoteObject(response.result), exceptionDetails: response.exceptionDetails};
   }
 
   /**
@@ -448,6 +447,32 @@
 /** @typedef {{timestamp: number, details: !Protocol.Runtime.ExceptionDetails}} */
 SDK.RuntimeModel.ExceptionWithTimestamp;
 
+/** @typedef {{
+ *    scriptId: (Protocol.Runtime.ScriptId|undefined),
+ *    exceptionDetails: (!Protocol.Runtime.ExceptionDetails|undefined)
+ *  }}
+ */
+SDK.RuntimeModel.CompileScriptResult;
+
+/** @typedef {{
+ *    expression: string,
+ *    objectGroup: (string|undefined),
+ *    includeCommandLineAPI: (boolean|undefined),
+ *    silent: (boolean|undefined),
+ *    returnByValue: (boolean|undefined),
+ *    generatePreview: (boolean|undefined)
+ *  }}
+ */
+SDK.RuntimeModel.EvaluationOptions;
+
+/** @typedef {{
+ *    object: (!SDK.RemoteObject|undefined),
+ *    exceptionDetails: (!Protocol.Runtime.ExceptionDetails|undefined),
+ *    error: (!Protocol.Error|undefined)}
+ *  }}
+ */
+SDK.RuntimeModel.EvaluationResult;
+
 /**
  * @typedef {{
  *    type: string,
@@ -598,79 +623,66 @@
   }
 
   /**
-   * @param {string} expression
-   * @param {string} objectGroup
-   * @param {boolean} includeCommandLineAPI
-   * @param {boolean} silent
-   * @param {boolean} returnByValue
-   * @param {boolean} generatePreview
+   * @param {!SDK.RuntimeModel.EvaluationOptions} options
    * @param {boolean} userGesture
-   * @param {function(?SDK.RemoteObject, !Protocol.Runtime.ExceptionDetails=, string=)} callback
+   * @param {boolean} awaitPromise
+   * @return {!Promise<!SDK.RuntimeModel.EvaluationResult>}
    */
-  evaluate(
-      expression,
-      objectGroup,
-      includeCommandLineAPI,
-      silent,
-      returnByValue,
-      generatePreview,
-      userGesture,
-      callback) {
+  evaluate(options, userGesture, awaitPromise) {
     // FIXME: It will be moved to separate ExecutionContext.
-    if (this.debuggerModel.selectedCallFrame()) {
-      this.debuggerModel.evaluateOnSelectedCallFrame(
-          expression, objectGroup, includeCommandLineAPI, silent, returnByValue, generatePreview, callback);
-      return;
-    }
-    this._evaluateGlobal(
-        expression, objectGroup, includeCommandLineAPI, silent, returnByValue, generatePreview, userGesture, callback);
+    if (this.debuggerModel.selectedCallFrame())
+      return this.debuggerModel.evaluateOnSelectedCallFrame(options);
+    return this._evaluateGlobal(options, userGesture, awaitPromise);
   }
 
   /**
    * @param {string} objectGroup
    * @param {boolean} generatePreview
-   * @param {function(?SDK.RemoteObject, !Protocol.Runtime.ExceptionDetails=, string=)} callback
+   * @return {!Promise<!SDK.RuntimeModel.EvaluationResult>}
    */
-  globalObject(objectGroup, generatePreview, callback) {
-    this._evaluateGlobal('this', objectGroup, false, true, false, generatePreview, false, callback);
+  globalObject(objectGroup, generatePreview) {
+    return this._evaluateGlobal(
+        {
+          expression: 'this',
+          objectGroup: objectGroup,
+          includeCommandLineAPI: false,
+          silent: true,
+          returnByValue: false,
+          generatePreview: generatePreview
+        },
+        /* userGesture */ false, /* awaitPromise */ false);
   }
 
   /**
-   * @param {string} expression
-   * @param {string} objectGroup
-   * @param {boolean} includeCommandLineAPI
-   * @param {boolean} silent
-   * @param {boolean} returnByValue
-   * @param {boolean} generatePreview
+   * @param {!SDK.RuntimeModel.EvaluationOptions} options
    * @param {boolean} userGesture
-   * @param {function(?SDK.RemoteObject, !Protocol.Runtime.ExceptionDetails=, string=)} callback
+   * @param {boolean} awaitPromise
+   * @return {!Promise<!SDK.RuntimeModel.EvaluationResult>}
    */
-  async _evaluateGlobal(
-      expression, objectGroup, includeCommandLineAPI, silent, returnByValue, generatePreview, userGesture, callback) {
-    if (!expression) {
+  async _evaluateGlobal(options, userGesture, awaitPromise) {
+    if (!options.expression) {
       // There is no expression, so the completion should happen against global properties.
-      expression = 'this';
+      options.expression = 'this';
     }
 
     var response = await this.runtimeModel._agent.invoke_evaluate({
-      expression: expression,
-      objectGroup: objectGroup,
-      includeCommandLineAPI: includeCommandLineAPI,
-      silent: silent,
+      expression: options.expression,
+      objectGroup: options.objectGroup,
+      includeCommandLineAPI: options.includeCommandLineAPI,
+      silent: options.silent,
       contextId: this.id,
-      returnByValue: returnByValue,
-      generatePreview: generatePreview,
+      returnByValue: options.returnByValue,
+      generatePreview: options.generatePreview,
       userGesture: userGesture,
-      awaitPromise: false
+      awaitPromise: awaitPromise
     });
 
     var error = response[Protocol.Error];
     if (error) {
       console.error(error);
-      callback(null, undefined, error);
-      return;
+      return {error: error};
     }
-    callback(this.runtimeModel.createRemoteObject(response.result), response.exceptionDetails);
+    return {object: this.runtimeModel.createRemoteObject(response.result), exceptionDetails: response.exceptionDetails};
   }
 
   /**

third_party/WebKit/Source/devtools/front_end/snippets/ScriptSnippetModel.js

diff --git a/third_party/WebKit/Source/devtools/front_end/snippets/ScriptSnippetModel.js b/third_party/WebKit/Source/devtools/front_end/snippets/ScriptSnippetModel.js
index bcfb866..90093ab2 100644
--- a/third_party/WebKit/Source/devtools/front_end/snippets/ScriptSnippetModel.js
+++ b/third_party/WebKit/Source/devtools/front_end/snippets/ScriptSnippetModel.js
@@ -221,8 +221,9 @@
   /**
    * @param {!SDK.ExecutionContext} executionContext
    * @param {!Workspace.UISourceCode} uiSourceCode
+   * @return {!Promise<undefined>}
    */
-  evaluateScriptSnippet(executionContext, uiSourceCode) {
+  async evaluateScriptSnippet(executionContext, uiSourceCode) {
     console.assert(uiSourceCode.project().type() === Workspace.projectTypes.Snippets);
     var breakpointLocations = this._removeBreakpoints(uiSourceCode);
     this._releaseSnippetScript(uiSourceCode);
@@ -234,40 +235,25 @@
     var mapping = this._mappingForDebuggerModel.get(debuggerModel);
     mapping._setEvaluationIndex(evaluationIndex, uiSourceCode);
     var evaluationUrl = mapping._evaluationSourceURL(uiSourceCode);
-    uiSourceCode.requestContent().then(compileSnippet.bind(this));
-
-    /**
-     * @this {Snippets.ScriptSnippetModel}
-     */
-    function compileSnippet() {
-      var expression = uiSourceCode.workingCopy();
-      Common.console.show();
-      runtimeModel.compileScript(expression, '', true, executionContext.id, compileCallback.bind(this));
+    await uiSourceCode.requestContent();
+    var expression = uiSourceCode.workingCopy();
+    Common.console.show();
+    var result = await runtimeModel.compileScript(expression, '', true, executionContext.id);
+    if (!result || mapping.evaluationIndex(uiSourceCode) !== evaluationIndex)
+      return;
+    var script = /** @type {!SDK.Script} */ (
+        debuggerModel.scriptForId(/** @type {string} */ (result.scriptId || result.exceptionDetails.scriptId)));
+    mapping._addScript(script, uiSourceCode);
+    if (!result.scriptId) {
+      this._printRunOrCompileScriptResultFailure(
+          runtimeModel, /** @type {!Protocol.Runtime.ExceptionDetails} */ (result.exceptionDetails), evaluationUrl);
+      return;
     }
 
-    /**
-     * @param {!Protocol.Runtime.ScriptId=} scriptId
-     * @param {?Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     * @this {Snippets.ScriptSnippetModel}
-     */
-    function compileCallback(scriptId, exceptionDetails) {
-      if (mapping.evaluationIndex(uiSourceCode) !== evaluationIndex)
-        return;
+    breakpointLocations = this._removeBreakpoints(uiSourceCode);
+    this._restoreBreakpoints(uiSourceCode, breakpointLocations);
 
-      var script = /** @type {!SDK.Script} */ (
-          debuggerModel.scriptForId(/** @type {string} */ (scriptId || exceptionDetails.scriptId)));
-      mapping._addScript(script, uiSourceCode);
-      if (!scriptId) {
-        this._printRunOrCompileScriptResultFailure(
-            runtimeModel, /** @type {!Protocol.Runtime.ExceptionDetails} */ (exceptionDetails), evaluationUrl);
-        return;
-      }
-
-      var breakpointLocations = this._removeBreakpoints(uiSourceCode);
-      this._restoreBreakpoints(uiSourceCode, breakpointLocations);
-
-      this._runScript(scriptId, executionContext, evaluationUrl);
-    }
+    this._runScript(script.scriptId, executionContext, evaluationUrl);
   }
 
   /**
@@ -275,28 +261,22 @@
    * @param {!SDK.ExecutionContext} executionContext
    * @param {?string=} sourceURL
    */
-  _runScript(scriptId, executionContext, sourceURL) {
+  async _runScript(scriptId, executionContext, sourceURL) {
     var runtimeModel = executionContext.runtimeModel;
-    runtimeModel.runScript(
+    var result = await runtimeModel.runScript(
         scriptId, executionContext.id, 'console', /* silent */ false, /* includeCommandLineAPI */ true,
-        /* returnByValue */ false, /* generatePreview */ true, /* awaitPromise */ undefined, runCallback.bind(this));
-
-    /**
-     * @param {?Protocol.Runtime.RemoteObject} result
-     * @param {?Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     * @this {Snippets.ScriptSnippetModel}
-     */
-    function runCallback(result, exceptionDetails) {
-      if (!exceptionDetails)
-        this._printRunScriptResult(runtimeModel, result, scriptId, sourceURL);
-      else
-        this._printRunOrCompileScriptResultFailure(runtimeModel, exceptionDetails, sourceURL);
-    }
+        /* returnByValue */ false, /* generatePreview */ true);
+    if (result.error)
+      return;
+    if (!result.exceptionDetails)
+      this._printRunScriptResult(runtimeModel, result.object || null, scriptId, sourceURL);
+    else
+      this._printRunOrCompileScriptResultFailure(runtimeModel, result.exceptionDetails, sourceURL);
   }
 
   /**
    * @param {!SDK.RuntimeModel} runtimeModel
-   * @param {?Protocol.Runtime.RemoteObject} result
+   * @param {?SDK.RemoteObject} result
    * @param {!Protocol.Runtime.ScriptId} scriptId
    * @param {?string=} sourceURL
    */

third_party/WebKit/Source/devtools/front_end/sources/JavaScriptCompiler.js

diff --git a/third_party/WebKit/Source/devtools/front_end/sources/JavaScriptCompiler.js b/third_party/WebKit/Source/devtools/front_end/sources/JavaScriptCompiler.js
index 2ffe87d8..a4b80dd 100644
--- a/third_party/WebKit/Source/devtools/front_end/sources/JavaScriptCompiler.js
+++ b/third_party/WebKit/Source/devtools/front_end/sources/JavaScriptCompiler.js
@@ -38,7 +38,7 @@
     return SDK.targetManager.mainTarget() ? SDK.targetManager.mainTarget().model(SDK.RuntimeModel) : null;
   }
 
-  _compile() {
+  async _compile() {
     var runtimeModel = this._findRuntimeModel();
     if (!runtimeModel)
       return;
@@ -48,27 +48,22 @@
 
     this._compiling = true;
     var code = this._sourceFrame.textEditor.text();
-    runtimeModel.compileScript(code, '', false, currentExecutionContext.id, compileCallback.bind(this));
-
-    /**
-     * @param {!Protocol.Runtime.ScriptId=} scriptId
-     * @param {?Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     * @this {Sources.JavaScriptCompiler}
-     */
-    function compileCallback(scriptId, exceptionDetails) {
-      this._compiling = false;
-      if (this._recompileScheduled) {
-        delete this._recompileScheduled;
-        this.scheduleCompile();
-        return;
-      }
-      if (!exceptionDetails)
-        return;
-      var text = SDK.RuntimeModel.simpleTextFromException(exceptionDetails);
-      this._sourceFrame.uiSourceCode().addLineMessage(
-          Workspace.UISourceCode.Message.Level.Error, text, exceptionDetails.lineNumber, exceptionDetails.columnNumber);
-      this._compilationFinishedForTest();
+    var result = await runtimeModel.compileScript(code, '', false, currentExecutionContext.id);
+    if (!result)
+      return;
+    this._compiling = false;
+    if (this._recompileScheduled) {
+      delete this._recompileScheduled;
+      this.scheduleCompile();
+      return;
     }
+    if (!result.exceptionDetails)
+      return;
+    var exceptionDetails = result.exceptionDetails;
+    var text = SDK.RuntimeModel.simpleTextFromException(exceptionDetails);
+    this._sourceFrame.uiSourceCode().addLineMessage(
+        Workspace.UISourceCode.Message.Level.Error, text, exceptionDetails.lineNumber, exceptionDetails.columnNumber);
+    this._compilationFinishedForTest();
   }
 
   _compilationFinishedForTest() {

third_party/WebKit/Source/devtools/front_end/sources/JavaScriptSourceFrame.js

diff --git a/third_party/WebKit/Source/devtools/front_end/sources/JavaScriptSourceFrame.js b/third_party/WebKit/Source/devtools/front_end/sources/JavaScriptSourceFrame.js
index 595ac76..76c1919c 100644
--- a/third_party/WebKit/Source/devtools/front_end/sources/JavaScriptSourceFrame.js
+++ b/third_party/WebKit/Source/devtools/front_end/sources/JavaScriptSourceFrame.js
@@ -459,11 +459,17 @@
         var resolvedText = await Sources.SourceMapNamesResolver.resolveExpression(
             /** @type {!SDK.DebuggerModel.CallFrame} */ (selectedCallFrame), evaluationText, this._debuggerSourceCode,
             lineNumber, startHighlight, endHighlight);
-        var remoteObject = await selectedCallFrame.evaluatePromise(
-            resolvedText || evaluationText, 'popover', false, true, false, false);
-        if (!remoteObject)
+        var result = await selectedCallFrame.evaluate({
+          expression: resolvedText || evaluationText,
+          objectGroup: 'popover',
+          includeCommandLineAPI: false,
+          silent: true,
+          returnByValue: false,
+          generatePreview: false
+        });
+        if (!result.object)
           return false;
-        objectPopoverHelper = await ObjectUI.ObjectPopoverHelper.buildObjectPopover(remoteObject, popover);
+        objectPopoverHelper = await ObjectUI.ObjectPopoverHelper.buildObjectPopover(result.object, popover);
         var potentiallyUpdatedCallFrame = UI.context.flavor(SDK.DebuggerModel.CallFrame);
         if (!objectPopoverHelper || selectedCallFrame !== potentiallyUpdatedCallFrame) {
           debuggerModel.runtimeModel().releaseObjectGroup('popover');

third_party/WebKit/Source/devtools/front_end/sources/ObjectEventListenersSidebarPane.js

diff --git a/third_party/WebKit/Source/devtools/front_end/sources/ObjectEventListenersSidebarPane.js b/third_party/WebKit/Source/devtools/front_end/sources/ObjectEventListenersSidebarPane.js
index 620e252..88b7dcc 100644
--- a/third_party/WebKit/Source/devtools/front_end/sources/ObjectEventListenersSidebarPane.js
+++ b/third_party/WebKit/Source/devtools/front_end/sources/ObjectEventListenersSidebarPane.js
@@ -62,28 +62,22 @@
 
   /**
    * @param {!SDK.ExecutionContext} executionContext
-   * @return {!Promise<!SDK.RemoteObject>} object
+   * @return {!Promise<?SDK.RemoteObject>} object
    */
   _windowObjectInContext(executionContext) {
-    return new Promise(windowObjectInContext);
-    /**
-     * @param {function(?)} fulfill
-     * @param {function(*)} reject
-     */
-    function windowObjectInContext(fulfill, reject) {
-      executionContext.evaluate(
-          'self', Sources.ObjectEventListenersSidebarPane._objectGroupName, false, true, false, false, false,
-          mycallback);
-      /**
-       * @param {?SDK.RemoteObject} object
-       */
-      function mycallback(object) {
-        if (object)
-          fulfill(object);
-        else
-          reject(null);
-      }
-    }
+    return executionContext
+        .evaluate(
+            {
+              expression: 'self',
+              objectGroup: Sources.ObjectEventListenersSidebarPane._objectGroupName,
+              includeCommandLineAPI: false,
+              silent: true,
+              returnByValue: false,
+              generatePreview: false
+            },
+            /* userGesture */ false,
+            /* awaitPromise */ false)
+        .then(result => result.object && !result.exceptionDetails ? result.object : null);
   }
 
   /**

third_party/WebKit/Source/devtools/front_end/sources/SourceMapNamesResolver.js

diff --git a/third_party/WebKit/Source/devtools/front_end/sources/SourceMapNamesResolver.js b/third_party/WebKit/Source/devtools/front_end/sources/SourceMapNamesResolver.js
index de48d7d4..afd8471c 100644
--- a/third_party/WebKit/Source/devtools/front_end/sources/SourceMapNamesResolver.js
+++ b/third_party/WebKit/Source/devtools/front_end/sources/SourceMapNamesResolver.js
@@ -306,20 +306,24 @@
       return Promise.resolve(callFrame.thisObject());
 
     var thisMapping = thisMappings.valuesArray()[0];
-    var callback;
-    var promise = new Promise(fulfill => callback = fulfill);
-    callFrame.evaluate(thisMapping, 'backtrace', false, true, false, true, onEvaluated.bind(null, callback));
-    return promise;
+    return callFrame
+        .evaluate({
+          expression: thisMapping,
+          objectGroup: 'backtrace',
+          includeCommandLineAPI: false,
+          silent: true,
+          returnByValue: false,
+          generatePreview: true
+        })
+        .then(onEvaluated);
   }
 
   /**
-   * @param {function(!SDK.RemoteObject)} callback
-   * @param {?Protocol.Runtime.RemoteObject} evaluateResult
+   * @param {!SDK.RuntimeModel.EvaluationResult} result
+   * @return {?SDK.RemoteObject}
    */
-  function onEvaluated(callback, evaluateResult) {
-    var remoteObject = evaluateResult ? callFrame.debuggerModel.runtimeModel().createRemoteObject(evaluateResult) :
-                                        callFrame.thisObject();
-    callback(/** @type {!SDK.RemoteObject} */ (remoteObject));
+  function onEvaluated(result) {
+    return !result.exceptionDetails && result.object ? result.object : callFrame.thisObject();
   }
 };
 

third_party/WebKit/Source/devtools/front_end/sources/SourcesPanel.js

diff --git a/third_party/WebKit/Source/devtools/front_end/sources/SourcesPanel.js b/third_party/WebKit/Source/devtools/front_end/sources/SourcesPanel.js
index e3ca021..c28927dc 100644
--- a/third_party/WebKit/Source/devtools/front_end/sources/SourcesPanel.js
+++ b/third_party/WebKit/Source/devtools/front_end/sources/SourcesPanel.js
@@ -900,53 +900,44 @@
   /**
    * @param {!SDK.RemoteObject} remoteObject
    */
-  _saveToTempVariable(remoteObject) {
+  async _saveToTempVariable(remoteObject) {
     var currentExecutionContext = UI.context.flavor(SDK.ExecutionContext);
     if (!currentExecutionContext)
       return;
 
-    currentExecutionContext.globalObject('', false, didGetGlobalObject);
-    /**
-     * @param {?SDK.RemoteObject} global
-     * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
-     */
-    function didGetGlobalObject(global, exceptionDetails) {
-      /**
-       * @suppressReceiverCheck
-       * @this {Window}
-       */
-      function remoteFunction(value) {
-        var prefix = 'temp';
-        var index = 1;
-        while ((prefix + index) in this)
-          ++index;
-        var name = prefix + index;
-        this[name] = value;
-        return name;
-      }
-
-      if (!!exceptionDetails || !global) {
-        failedToSave(global);
-      } else {
-        global.callFunction(
-            remoteFunction, [SDK.RemoteObject.toCallArgument(remoteObject)], didSave.bind(null, global));
-      }
+    var result = await currentExecutionContext.globalObject(/* objectGroup */ '', /* generatePreview */ false);
+    if (!!result.exceptionDetails || !result.object) {
+      failedToSave(result.object || null);
+      return;
     }
 
+    var globalObject = result.object;
+    var callFunctionResult =
+        await globalObject.callFunctionPromise(saveVariable, [SDK.RemoteObject.toCallArgument(remoteObject)]);
+    globalObject.release();
+    if (callFunctionResult.wasThrown || !callFunctionResult.object || callFunctionResult.object.type !== 'string') {
+      failedToSave(callFunctionResult.object || null);
+    } else {
+      ConsoleModel.consoleModel.evaluateCommandInConsole(
+          /** @type {!SDK.ExecutionContext} */ (currentExecutionContext),
+          /** @type {string} */ (callFunctionResult.object.value),
+          /* useCommandLineAPI */ false);
+    }
+    if (callFunctionResult.object)
+      callFunctionResult.object.release();
+
     /**
-     * @param {!SDK.RemoteObject} global
-     * @param {?SDK.RemoteObject} result
-     * @param {boolean=} wasThrown
+     * @suppressReceiverCheck
+     * @this {Window}
      */
-    function didSave(global, result, wasThrown) {
-      global.release();
-      if (wasThrown || !result || result.type !== 'string') {
-        failedToSave(result);
-      } else {
-        ConsoleModel.consoleModel.evaluateCommandInConsole(
-            /** @type {!SDK.ExecutionContext} */ (currentExecutionContext), /** @type {string} */ (result.value),
-            /* useCommandLineAPI */ false);
-      }
+    function saveVariable(value) {
+      var prefix = 'temp';
+      var index = 1;
+      while ((prefix + index) in this)
+        ++index;
+      var name = prefix + index;
+      this[name] = value;
+      return name;
     }
 
     /**
@@ -954,10 +945,8 @@
      */
     function failedToSave(result) {
       var message = Common.UIString('Failed to save to temp variable.');
-      if (result) {
+      if (result)
         message += ' ' + result.description;
-        result.release();
-      }
       Common.console.error(message);
     }
   }

third_party/WebKit/Source/devtools/front_end/sources/WatchExpressionsSidebarPane.js

diff --git a/third_party/WebKit/Source/devtools/front_end/sources/WatchExpressionsSidebarPane.js b/third_party/WebKit/Source/devtools/front_end/sources/WatchExpressionsSidebarPane.js
index bc98f10..08f79be 100644
--- a/third_party/WebKit/Source/devtools/front_end/sources/WatchExpressionsSidebarPane.js
+++ b/third_party/WebKit/Source/devtools/front_end/sources/WatchExpressionsSidebarPane.js
@@ -227,7 +227,7 @@
     this._editing = false;
     this._linkifier = linkifier;
 
-    this._createWatchExpression(null);
+    this._createWatchExpression();
     this.update();
   }
 
@@ -248,9 +248,19 @@
   update() {
     var currentExecutionContext = UI.context.flavor(SDK.ExecutionContext);
     if (currentExecutionContext && this._expression) {
-      currentExecutionContext.evaluate(
-          this._expression, Sources.WatchExpression._watchObjectGroupId, false, true, false, false, false,
-          this._createWatchExpression.bind(this));
+      currentExecutionContext
+          .evaluate(
+              {
+                expression: this._expression,
+                objectGroup: Sources.WatchExpression._watchObjectGroupId,
+                includeCommandLineAPI: false,
+                silent: true,
+                returnByValue: false,
+                generatePreview: false
+              },
+              /* userGesture */ false,
+              /* awaitPromise */ false)
+          .then(result => this._createWatchExpression(result.object, result.exceptionDetails));
     }
   }
 
@@ -320,11 +330,11 @@
   }
 
   /**
-   * @param {?SDK.RemoteObject} result
+   * @param {!SDK.RemoteObject=} result
    * @param {!Protocol.Runtime.ExceptionDetails=} exceptionDetails
    */
   _createWatchExpression(result, exceptionDetails) {
-    this._result = result;
+    this._result = result || null;
 
     var headerElement = createElementWithClass('div', 'watch-expression-header');
     var deleteButton = headerElement.createChild('button', 'watch-expression-delete-button');

third_party/WebKit/Source/modules/vr/VRDisplay.cpp

diff --git a/third_party/WebKit/Source/modules/vr/VRDisplay.cpp b/third_party/WebKit/Source/modules/vr/VRDisplay.cpp
index 6fd3de4..942bf08a 100644
--- a/third_party/WebKit/Source/modules/vr/VRDisplay.cpp
+++ b/third_party/WebKit/Source/modules/vr/VRDisplay.cpp
@@ -420,8 +420,6 @@
     // original request returns.
     pending_present_resolvers_.push_back(resolver);
   } else if (first_present) {
-    bool secure_context =
-        ExecutionContext::From(script_state)->IsSecureContext();
     if (!display_) {
       ForceExitPresent();
       DOMException* exception = DOMException::Create(
@@ -435,7 +433,7 @@
     submit_frame_client_binding_.Close();
     submit_frame_client_binding_.Bind(mojo::MakeRequest(&submit_frame_client));
     display_->RequestPresent(
-        secure_context, std::move(submit_frame_client),
+        std::move(submit_frame_client),
         mojo::MakeRequest(&vr_presentation_provider_),
         ConvertToBaseCallback(
             WTF::Bind(&VRDisplay::OnPresentComplete, WrapPersistent(this))));

third_party/WebKit/Source/platform/BUILD.gn

diff --git a/third_party/WebKit/Source/platform/BUILD.gn b/third_party/WebKit/Source/platform/BUILD.gn
index b44915a5..57811c2 100644
--- a/third_party/WebKit/Source/platform/BUILD.gn
+++ b/third_party/WebKit/Source/platform/BUILD.gn
@@ -1138,6 +1138,8 @@
     "graphics/paint/ScopedPaintChunkProperties.h",
     "graphics/paint/ScrollDisplayItem.cpp",
     "graphics/paint/ScrollDisplayItem.h",
+    "graphics/paint/ScrollHitTestDisplayItem.cpp",
+    "graphics/paint/ScrollHitTestDisplayItem.h",
     "graphics/paint/ScrollPaintPropertyNode.cpp",
     "graphics/paint/ScrollPaintPropertyNode.h",
     "graphics/paint/SubsequenceRecorder.h",

third_party/WebKit/Source/platform/audio/VectorMath.h

diff --git a/third_party/WebKit/Source/platform/audio/VectorMath.h b/third_party/WebKit/Source/platform/audio/VectorMath.h
index a01b4093..8bc309a4 100644
--- a/third_party/WebKit/Source/platform/audio/VectorMath.h
+++ b/third_party/WebKit/Source/platform/audio/VectorMath.h
@@ -36,6 +36,8 @@
 namespace VectorMath {
 
 // Vector scalar multiply and then add.
+//
+// dest[k*dest_stride] += scale * source[k*source_stride]
 PLATFORM_EXPORT void Vsma(const float* source_p,
                           int source_stride,
                           const float* scale,
@@ -43,12 +45,19 @@
                           int dest_stride,
                           size_t frames_to_process);
 
+// Vector scalar multiply:
+//
+// dest[k*dest_stride] = scale * source[k*source_stride]
 PLATFORM_EXPORT void Vsmul(const float* source_p,
                            int source_stride,
                            const float* scale,
                            float* dest_p,
                            int dest_stride,
                            size_t frames_to_process);
+
+// Vector add:
+//
+// dest[k*dest_stride] = source1[k*source_stride1] + source2[source_stride2]
 PLATFORM_EXPORT void Vadd(const float* source1p,
                           int source_stride1,
                           const float* source2p,
@@ -57,19 +66,25 @@
                           int dest_stride,
                           size_t frames_to_process);
 
-// Finds the maximum magnitude of a float vector.
+// Finds the maximum magnitude of a float vector:
+//
+// max = max(abs(source[k*source_stride])) for all k.
 PLATFORM_EXPORT void Vmaxmgv(const float* source_p,
                              int source_stride,
                              float* max_p,
                              size_t frames_to_process);
 
-// Sums the squares of a float vector's elements.
+// Sums the squares of a float vector's elements:
+//
+// sum = sum(source[k*source_stride]^2, k = 0, frames_to_process);
 PLATFORM_EXPORT void Vsvesq(const float* source_p,
                             int source_stride,
                             float* sum_p,
                             size_t frames_to_process);
 
-// For an element-by-element multiply of two float vectors.
+// For an element-by-element multiply of two float vectors:
+//
+// dest[k*dest_stride] = source1[k*source_stride1] * source2[k*source_stride2]
 PLATFORM_EXPORT void Vmul(const float* source1p,
                           int source_stride1,
                           const float* source2p,
@@ -78,7 +93,10 @@
                           int dest_stride,
                           size_t frames_to_process);
 
-// Multiplies two complex vectors.
+// Multiplies two complex vectors.  Complex version of Vmul where |rea1p| and
+// |imag1p| forms the real and complex components of source1; |real2p| and
+// |imag2p| the components of source2, and |real_dest_p| and |imag_dest_p|, the
+// components of the destination.
 PLATFORM_EXPORT void Zvmul(const float* real1p,
                            const float* imag1p,
                            const float* real2p,
@@ -88,6 +106,11 @@
                            size_t frames_to_process);
 
 // Copies elements while clipping values to the threshold inputs.
+//
+// dest[k*dest_stride] = clip(source[k*source_stride], low, high)
+//
+// where y = clip(x, low, high) = max(low, min(x, high)), effectively making
+// low <= y <= high.
 PLATFORM_EXPORT void Vclip(const float* source_p,
                            int source_stride,
                            const float* low_threshold_p,

third_party/WebKit/Source/platform/graphics/OffscreenCanvasFrameDispatcherImpl.cpp

diff --git a/third_party/WebKit/Source/platform/graphics/OffscreenCanvasFrameDispatcherImpl.cpp b/third_party/WebKit/Source/platform/graphics/OffscreenCanvasFrameDispatcherImpl.cpp
index 5135517..24f2bbb4 100644
--- a/third_party/WebKit/Source/platform/graphics/OffscreenCanvasFrameDispatcherImpl.cpp
+++ b/third_party/WebKit/Source/platform/graphics/OffscreenCanvasFrameDispatcherImpl.cpp
@@ -309,7 +309,7 @@
 
   pending_compositor_frames_++;
   sink_->SubmitCompositorFrame(current_local_surface_id_, std::move(frame),
-                               nullptr);
+                               nullptr, 0);
 }
 
 void OffscreenCanvasFrameDispatcherImpl::DidReceiveCompositorFrameAck(

third_party/WebKit/Source/platform/graphics/compositing/PaintChunksToCcLayer.cpp

diff --git a/third_party/WebKit/Source/platform/graphics/compositing/PaintChunksToCcLayer.cpp b/third_party/WebKit/Source/platform/graphics/compositing/PaintChunksToCcLayer.cpp
index 849f88bc..abe88d5 100644
--- a/third_party/WebKit/Source/platform/graphics/compositing/PaintChunksToCcLayer.cpp
+++ b/third_party/WebKit/Source/platform/graphics/compositing/PaintChunksToCcLayer.cpp
@@ -22,7 +22,10 @@
 constexpr gfx::Rect g_large_rect(-200000, -200000, 400000, 400000);
 void AppendDisplayItemToCcDisplayItemList(const DisplayItem& display_item,
                                           cc::DisplayItemList& list) {
-  DCHECK(DisplayItem::IsDrawingType(display_item.GetType()));
+  // TODO(pdr): Change this to a DCHECK once scroll hit test display items
+  // are no longer appended (crbug.com/738613).
+  if (!display_item.IsDrawing())
+    return;
 
   sk_sp<const PaintRecord> record =
       static_cast<const DrawingDisplayItem&>(display_item).GetPaintRecord();

third_party/WebKit/Source/platform/graphics/paint/DisplayItem.cpp

diff --git a/third_party/WebKit/Source/platform/graphics/paint/DisplayItem.cpp b/third_party/WebKit/Source/platform/graphics/paint/DisplayItem.cpp
index 224bceb0..6a939631 100644
--- a/third_party/WebKit/Source/platform/graphics/paint/DisplayItem.cpp
+++ b/third_party/WebKit/Source/platform/graphics/paint/DisplayItem.cpp
@@ -129,6 +129,13 @@
   }
 }
 
+static String ScrollHitTestTypeAsDebugString(DisplayItem::Type type) {
+  switch (type) {
+    DEBUG_STRING_CASE(ScrollHitTest);
+    DEFAULT_CASE;
+  }
+}
+
 static WTF::String ClipTypeAsDebugString(DisplayItem::Type type) {
   PAINT_PHASE_BASED_DEBUG_STRINGS(ClipBox);
   PAINT_PHASE_BASED_DEBUG_STRINGS(ClipColumnBounds);
@@ -194,6 +201,9 @@
     return "End" + Transform3DTypeAsDebugString(
                        endTransform3DTypeToTransform3DType(type));
 
+  if (IsScrollHitTestType(type))
+    return ScrollHitTestTypeAsDebugString(type);
+
   switch (type) {
     DEBUG_STRING_CASE(BeginFilter);
     DEBUG_STRING_CASE(EndFilter);

third_party/WebKit/Source/platform/graphics/paint/DisplayItem.h

diff --git a/third_party/WebKit/Source/platform/graphics/paint/DisplayItem.h b/third_party/WebKit/Source/platform/graphics/paint/DisplayItem.h
index 24acce16..3cbb94c1 100644
--- a/third_party/WebKit/Source/platform/graphics/paint/DisplayItem.h
+++ b/third_party/WebKit/Source/platform/graphics/paint/DisplayItem.h
@@ -173,6 +173,7 @@
     kEndTransform,
     kBeginClipPath,
     kEndClipPath,
+    kScrollHitTest,
     kUninitializedType,
     kTypeLast = kUninitializedType
   };
@@ -307,6 +308,10 @@
 
   DEFINE_PAIRED_CATEGORY_METHODS(Transform3D, transform3D)
 
+  static bool IsScrollHitTestType(Type type) { return type == kScrollHitTest; }
+  bool IsScrollHitTest() const { return IsScrollHitTestType(type_); }
+
+  // TODO(pdr): Should this return true for IsScrollHitTestType too?
   static bool IsCacheableType(Type type) { return IsDrawingType(type); }
   bool IsCacheable() const { return !SkippedCache() && IsCacheableType(type_); }
 

third_party/WebKit/Source/platform/graphics/paint/README.md

diff --git a/third_party/WebKit/Source/platform/graphics/paint/README.md b/third_party/WebKit/Source/platform/graphics/paint/README.md
index c6ccf10..f3033e1 100644
--- a/third_party/WebKit/Source/platform/graphics/paint/README.md
+++ b/third_party/WebKit/Source/platform/graphics/paint/README.md
@@ -170,6 +170,13 @@
 to a `cc::Layer`, they are always the only display item in their paint chunk,
 and are ineligible for squashing with other layers.
 
+#### [ScrollHitTestDisplayItem](ScrollHitTestDisplayItem.h)
+
+Placeholder for creating a cc::Layer for scrolling in paint order. Hit testing
+in the compositor requires both property trees (scroll nodes) and a scrollable
+`cc::layer` in paint order. This should be associated with the scroll
+translation paint property node as well as any overflow clip nodes.
+
 ### Paired begin/end display items
 
 *** aside

third_party/WebKit/Source/platform/graphics/paint/ScrollHitTestDisplayItem.cpp

diff --git a/third_party/WebKit/Source/platform/graphics/paint/ScrollHitTestDisplayItem.cpp b/third_party/WebKit/Source/platform/graphics/paint/ScrollHitTestDisplayItem.cpp
new file mode 100644
index 0000000..cdacb33
--- /dev/null
+++ b/third_party/WebKit/Source/platform/graphics/paint/ScrollHitTestDisplayItem.cpp
@@ -0,0 +1,59 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "platform/graphics/paint/ScrollHitTestDisplayItem.h"
+
+#include "platform/graphics/GraphicsContext.h"
+#include "platform/graphics/paint/PaintController.h"
+#include "platform/wtf/Assertions.h"
+
+namespace blink {
+
+ScrollHitTestDisplayItem::ScrollHitTestDisplayItem(
+    const DisplayItemClient& client,
+    Type type)
+    : DisplayItem(client, type, sizeof(*this)) {
+  DCHECK(RuntimeEnabledFeatures::SlimmingPaintV2Enabled());
+  DCHECK(IsScrollHitTestType(type));
+}
+
+ScrollHitTestDisplayItem::~ScrollHitTestDisplayItem() {}
+
+void ScrollHitTestDisplayItem::Replay(GraphicsContext&) const {
+  NOTREACHED();
+}
+
+void ScrollHitTestDisplayItem::AppendToWebDisplayItemList(
+    const LayoutSize&,
+    WebDisplayItemList*) const {
+  NOTREACHED();
+}
+
+bool ScrollHitTestDisplayItem::Equals(const DisplayItem& other) const {
+  return DisplayItem::Equals(other);
+}
+
+#ifndef NDEBUG
+void ScrollHitTestDisplayItem::DumpPropertiesAsDebugString(
+    StringBuilder& string_builder) const {
+  DisplayItem::DumpPropertiesAsDebugString(string_builder);
+}
+#endif  // NDEBUG
+
+void ScrollHitTestDisplayItem::Record(GraphicsContext& context,
+                                      const DisplayItemClient& client,
+                                      DisplayItem::Type type) {
+  PaintController& paint_controller = context.GetPaintController();
+  if (paint_controller.DisplayItemConstructionIsDisabled())
+    return;
+
+  // Should be contained in a scroll translation node.
+  DCHECK(paint_controller.CurrentPaintChunkProperties()
+             .property_tree_state.Transform()
+             ->ScrollNode());
+
+  paint_controller.CreateAndAppend<ScrollHitTestDisplayItem>(client, type);
+}
+
+}  // namespace blink

third_party/WebKit/Source/platform/graphics/paint/ScrollHitTestDisplayItem.h

diff --git a/third_party/WebKit/Source/platform/graphics/paint/ScrollHitTestDisplayItem.h b/third_party/WebKit/Source/platform/graphics/paint/ScrollHitTestDisplayItem.h
new file mode 100644
index 0000000..10a3d35
--- /dev/null
+++ b/third_party/WebKit/Source/platform/graphics/paint/ScrollHitTestDisplayItem.h
@@ -0,0 +1,44 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ScrollHitTestDisplayItem_h
+#define ScrollHitTestDisplayItem_h
+
+#include "base/memory/ref_counted.h"
+#include "platform/PlatformExport.h"
+#include "platform/RuntimeEnabledFeatures.h"
+#include "platform/graphics/paint/DisplayItem.h"
+
+namespace blink {
+
+class GraphicsContext;
+
+// Placeholder display item for creating a special cc::Layer marked as being
+// scrollable in PaintArtifactCompositor. A display item is needed because
+// scroll hit testing must be in paint order.
+class PLATFORM_EXPORT ScrollHitTestDisplayItem final : public DisplayItem {
+ public:
+  ScrollHitTestDisplayItem(const DisplayItemClient&, Type);
+  ~ScrollHitTestDisplayItem();
+
+  // DisplayItem
+  void Replay(GraphicsContext&) const override;
+  void AppendToWebDisplayItemList(const LayoutSize&,
+                                  WebDisplayItemList*) const override;
+  bool Equals(const DisplayItem&) const override;
+#ifndef NDEBUG
+  void DumpPropertiesAsDebugString(StringBuilder&) const override;
+#endif
+
+  // Create and append a ScrollHitTestDisplayItem onto the context. This is
+  // similar to a recorder class (e.g., DrawingRecorder) but just emits a single
+  // item.
+  static void Record(GraphicsContext&,
+                     const DisplayItemClient&,
+                     DisplayItem::Type);
+};
+
+}  // namespace blink
+
+#endif  // ScrollHitTestDisplayItem_h

third_party/WebKit/Tools/Scripts/webkitpy/w3c/common.py

diff --git a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/common.py b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/common.py
index 4f2760bf..749abdc 100644
--- a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/common.py
+++ b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/common.py
@@ -31,6 +31,9 @@
         host, local_wpt, wpt_github, number=DEFAULT_COMMIT_HISTORY_WINDOW):
     """Lists exportable commits after a certain point.
 
+    Exportable commits can be applied cleanly against the upstream HEAD and
+    produce non-empty diff.
+
     Args:
         number: The number of commits back to look. The commits to check will
             include all commits starting from the commit before HEAD~n, up
@@ -41,26 +44,23 @@
         wpt_github: A WPTGitHub instance, used to check whether PRs are closed.
 
     Returns:
-        A list of ChromiumCommit objects for commits that are exportable after
-        the given commit, in chronological order.
+        (exportable_commits, errors) where exportable_commits is a list of
+        ChromiumCommit objects for commits that are exportable after the
+        given commit, and errors is a list of error messages when otherwise
+        exportable patches fail to apply cleanly, both in chronological order.
     """
     start_commit = 'HEAD~{}'.format(number + 1)
     return _exportable_commits_since(start_commit, host, local_wpt, wpt_github)
 
 
 def _exportable_commits_since(chromium_commit_hash, host, local_wpt, wpt_github):
-    """Lists exportable commits after a certain point.
+    """Lists exportable commits after the given commit.
 
     Args:
         chromium_commit_hash: The SHA of the Chromium commit from which this
             method will look. This commit is not included in the commits searched.
-        host: A Host object.
-        local_wpt: A LocalWPT instance.
-        wpt_github: A WPTGitHub instance.
 
-    Returns:
-        A list of ChromiumCommit objects for commits that are exportable after
-        the given commit, in chronological order.
+    Return values and remaining arguments are the same as exportable_commits_over_last_n_commits.
     """
     chromium_repo_root = host.executive.run_command([
         'git', 'rev-parse', '--show-toplevel'
@@ -73,33 +73,42 @@
     ], cwd=absolute_chromium_dir(host)).splitlines()
     chromium_commits = [ChromiumCommit(host, sha=sha) for sha in commit_hashes]
     exportable_commits = []
+    errors = []
     for commit in chromium_commits:
-        if is_exportable(commit, local_wpt, wpt_github):
+        success, error = _is_commit_exportable(commit, local_wpt, wpt_github)
+        if success:
             exportable_commits.append(commit)
-    return exportable_commits
+        elif error != '':
+            errors.append('The following commit did not apply cleanly:\nSubject: %s (%s)\n%s' %
+                          (commit.subject(), commit.url(), error))
+    return exportable_commits, errors
 
 
-def is_exportable(chromium_commit, local_wpt, wpt_github):
-    """Checks whether a given patch is exportable and can be applied."""
+def _is_commit_exportable(chromium_commit, local_wpt, wpt_github):
+    """Checks whether a given patch is exportable and can be applied.
+
+    Returns:
+        (success, error): success is True if and only if the patch is
+        exportable, applies cleanly, and produces non-empty diff;
+        error is a string of error messages if the patch fails to apply
+        or produces empty diff but is otherwise exportable.
+    """
     message = chromium_commit.message()
     if 'NOEXPORT=true' in message or 'No-Export: true' in message or message.startswith('Import'):
-        return False
+        return False, ''
 
     patch = chromium_commit.format_patch()
     if not patch:
-        return False
+        return False, ''
 
     # If there's a corresponding closed PR, then this commit should not
     # be considered exportable; the PR might have been merged and reverted,
     # or it might have been closed manually without merging.
     pull_request = wpt_github.pr_for_chromium_commit(chromium_commit)
     if pull_request and pull_request.state == 'closed':
-        return False
+        return False, ''
 
-    if not local_wpt.test_patch(patch, chromium_commit):
-        return False
-
-    return True
+    return local_wpt.test_patch(patch)
 
 
 def read_credentials(host, credentials_json):

third_party/WebKit/Tools/Scripts/webkitpy/w3c/common_unittest.py

diff --git a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/common_unittest.py b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/common_unittest.py
index 270dde5..9f2f01d 100644
--- a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/common_unittest.py
+++ b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/common_unittest.py
@@ -10,16 +10,20 @@
 from webkitpy.w3c.chromium_commit import ChromiumCommit
 from webkitpy.w3c.chromium_commit_mock import MockChromiumCommit
 from webkitpy.w3c.common import _exportable_commits_since
+from webkitpy.w3c.common import _is_commit_exportable
 from webkitpy.w3c.common import read_credentials
-from webkitpy.w3c.common import is_exportable
 from webkitpy.w3c.wpt_github import PullRequest
 from webkitpy.w3c.wpt_github_mock import MockWPTGitHub
 
 
 class MockLocalWPT(object):
 
-    def test_patch(self, *_):
-        return 'patch'
+    def __init__(self, patch_success=True, patch_error=''):
+        self.patch_success = patch_success
+        self.patch_error = patch_error
+
+    def test_patch(self, _):
+        return self.patch_success, self.patch_error
 
 
 class CommonTest(unittest.TestCase):
@@ -39,7 +43,7 @@
             'footers': 'cr-rev-position',
         })
 
-        commits = _exportable_commits_since(
+        commits, _ = _exportable_commits_since(
             'beefcafe', host, MockLocalWPT(), MockWPTGitHub(pull_requests=[]))
         self.assertEqual(len(commits), 1)
         self.assertIsInstance(commits[0], ChromiumCommit)
@@ -54,38 +58,38 @@
             ['git', 'format-patch', '-1', '--stdout', 'add087a97844f4b9e307d9a216940582d96db306', '--', 'some', 'files'],
         ])
 
-    def test_is_exportable(self):
+    def test_is_commit_exportable(self):
         commit = MockChromiumCommit(MockHost())
         github = MockWPTGitHub(pull_requests=[])
-        self.assertTrue(is_exportable(commit, MockLocalWPT(), github))
+        self.assertEqual(_is_commit_exportable(commit, MockLocalWPT(), github), (True, ''))
 
     def test_commit_with_noexport_is_not_exportable(self):
         commit = MockChromiumCommit(MockHost(), body='Message\nNo-Export: true')
         github = MockWPTGitHub(pull_requests=[])
-        self.assertFalse(is_exportable(commit, MockLocalWPT(), github))
+        self.assertEqual(_is_commit_exportable(commit, MockLocalWPT(), github), (False, ''))
 
         # The older NOEXPORT tag also makes it non-exportable.
         old_commit = MockChromiumCommit(MockHost(), body='Message\nNOEXPORT=true')
-        self.assertFalse(is_exportable(old_commit, MockLocalWPT(), github))
+        self.assertEqual(_is_commit_exportable(old_commit, MockLocalWPT(), github), (False, ''))
 
         # No-Export/NOEXPORT in a revert CL also makes it non-exportable.
         revert = MockChromiumCommit(MockHost(), body='Revert of Message\n> No-Export: true')
-        self.assertFalse(is_exportable(revert, MockLocalWPT(), github))
+        self.assertEqual(_is_commit_exportable(revert, MockLocalWPT(), github), (False, ''))
         old_revert = MockChromiumCommit(MockHost(), body='Revert of Message\n> NOEXPORT=true')
-        self.assertFalse(is_exportable(old_revert, MockLocalWPT(), github))
+        self.assertEqual(_is_commit_exportable(old_revert, MockLocalWPT(), github), (False, ''))
 
     def test_commit_that_starts_with_import_is_not_exportable(self):
         commit = MockChromiumCommit(MockHost(), subject='Import message')
         github = MockWPTGitHub(pull_requests=[])
-        self.assertFalse(is_exportable(commit, MockLocalWPT(), github))
+        self.assertEqual(_is_commit_exportable(commit, MockLocalWPT(), github), (False, ''))
 
-    def test_commit_that_has_open_pr_is_exportable(self):
+    def test_commit_that_has_open_pr_is_commit_exportable(self):
         commit = MockChromiumCommit(MockHost(), change_id='I00decade')
         github = MockWPTGitHub(pull_requests=[
             PullRequest('PR1', 1, 'body\nChange-Id: I00c0ffee', 'closed', []),
             PullRequest('PR2', 2, 'body\nChange-Id: I00decade', 'open', []),
         ])
-        self.assertTrue(is_exportable(commit, MockLocalWPT(), github))
+        self.assertEqual(_is_commit_exportable(commit, MockLocalWPT(), github), (True, ''))
 
     def test_commit_that_has_closed_pr_is_not_exportable(self):
         commit = MockChromiumCommit(MockHost(), change_id='I00decade')
@@ -93,7 +97,17 @@
             PullRequest('PR1', 1, 'body\nChange-Id: I00c0ffee', 'closed', []),
             PullRequest('PR2', 2, 'body\nChange-Id: I00decade', 'closed', []),
         ])
-        self.assertFalse(is_exportable(commit, MockLocalWPT(), github))
+        self.assertEqual(_is_commit_exportable(commit, MockLocalWPT(), github), (False, ''))
+
+    def test_commit_that_produces_errors(self):
+        commit = MockChromiumCommit(MockHost())
+        github = MockWPTGitHub(pull_requests=[])
+        self.assertEqual(_is_commit_exportable(commit, MockLocalWPT(False, 'error'), github), (False, 'error'))
+
+    def test_commit_that_produces_empty_diff(self):
+        commit = MockChromiumCommit(MockHost())
+        github = MockWPTGitHub(pull_requests=[])
+        self.assertEqual(_is_commit_exportable(commit, MockLocalWPT(False, ''), github), (False, ''))
 
     def test_get_credentials_empty(self):
         host = MockHost()

third_party/WebKit/Tools/Scripts/webkitpy/w3c/directory_owners_extractor.py

diff --git a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/directory_owners_extractor.py b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/directory_owners_extractor.py
index a01d46ba..a48b18e 100644
--- a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/directory_owners_extractor.py
+++ b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/directory_owners_extractor.py
@@ -70,7 +70,8 @@
         # not raise an assertion.
         if directory == self.finder.layout_tests_dir():
             return None, None
-        assert directory.startswith(external_root)
+        assert directory.startswith(external_root), '%s must start with %s' % (
+            directory, external_root)
         while directory != external_root:
             owners_file = self.filesystem.join(directory, 'OWNERS')
             if self.filesystem.isfile(self.finder.path_from_chromium_base(owners_file)):

third_party/WebKit/Tools/Scripts/webkitpy/w3c/local_wpt.py

diff --git a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/local_wpt.py b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/local_wpt.py
index 1765f73..017212e 100644
--- a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/local_wpt.py
+++ b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/local_wpt.py
@@ -101,31 +101,34 @@
         else:
             self.run(['git', 'push', 'origin', branch_name])
 
-    def test_patch(self, patch, chromium_commit=None):
-        """Returns the expected output of a patch against origin/master.
+    def test_patch(self, patch):
+        """Tests whether a patch can be cleanly applied against origin/master.
 
         Args:
             patch: The patch to test against.
-            chromium_commit: The ChromiumCommit, for logging extra info.
 
         Returns:
-            A string containing the diff the patch produced.
+            (success, error): success is True if and only if the patch can be
+            cleanly applied and produce non-empty diff; error is a string of
+            error messages when the patch fails to apply, empty otherwise.
         """
         self.clean()
-        applied = self.apply_patch(patch)
-        output = self.run(['git', 'diff', 'origin/master'])
+        error = self.apply_patch(patch)
+        diff = self.run(['git', 'diff', 'origin/master'])
         self.clean()
-        if applied:
-            return output
-        if chromium_commit:
-            _log.info('Commit: %s', chromium_commit.url())
-            _log.info('Commit subject: "%s"', chromium_commit.subject())
-        return ''
+        if error != '':
+            return False, error
+        if diff == '':
+            # No error message is returned for empty diff. The patch might be
+            # empty or has been exported.
+            return False, ''
+        return True, ''
 
     def apply_patch(self, patch):
         """Applies a Chromium patch to the local WPT repo and stages.
 
-        Returns True if the patch could be applied, false otherwise.
+        Returns:
+            A string containing error messages from git, empty if the patch applies cleanly.
         """
         # Remove Chromium WPT directory prefix.
         patch = patch.replace(CHROMIUM_WPT_DIR, '')
@@ -133,10 +136,8 @@
             self.run(['git', 'apply', '-'], input=patch)
             self.run(['git', 'add', '.'])
         except ScriptError as error:
-            _log.warning('Patch did not apply cleanly for the following commit:')
-            _log.warning('Message: %s\n\n', error.message)
-            return False
-        return True
+            return error.message
+        return ''
 
     def commits_behind_master(self, commit):
         """Returns the number of commits after the given commit on origin/master.

third_party/WebKit/Tools/Scripts/webkitpy/w3c/local_wpt_unittest.py

diff --git a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/local_wpt_unittest.py b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/local_wpt_unittest.py
index d49f107..157df03 100644
--- a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/local_wpt_unittest.py
+++ b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/local_wpt_unittest.py
@@ -5,6 +5,8 @@
 import unittest
 
 from webkitpy.common.host_mock import MockHost
+from webkitpy.common.system.executive import ScriptError
+from webkitpy.common.system.executive_mock import MockExecutive, mock_git_commands
 from webkitpy.common.system.filesystem_mock import MockFileSystem
 from webkitpy.w3c.local_wpt import LocalWPT
 
@@ -27,8 +29,6 @@
 
     def test_fetch_when_wpt_dir_does_not_exist(self):
         host = MockHost()
-        host.filesystem = MockFileSystem()
-
         local_wpt = LocalWPT(host, 'token')
         local_wpt.fetch()
 
@@ -43,15 +43,12 @@
 
     def test_run(self):
         host = MockHost()
-        host.filesystem = MockFileSystem()
         local_wpt = LocalWPT(host, 'token')
         local_wpt.run(['echo', 'rutabaga'])
         self.assertEqual(host.executive.calls, [['echo', 'rutabaga']])
 
     def test_create_branch_with_patch(self):
         host = MockHost()
-        host.filesystem = MockFileSystem()
-
         local_wpt = LocalWPT(host, 'token')
         local_wpt.fetch()
 
@@ -67,3 +64,43 @@
             ['git', 'add', '.'],
             ['git', 'commit', '--author', 'author <author@author.com>', '-am', 'message'],
             ['git', 'push', 'origin', 'chromium-export-decafbad']])
+
+    def test_test_patch_success(self):
+        host = MockHost()
+        host.executive = mock_git_commands({
+            'apply': '',
+            'add': '',
+            'diff': 'non-trivial patch',
+            'reset': '',
+            'clean': '',
+            'checkout': '',
+        }, strict=True)
+        local_wpt = LocalWPT(host, 'token')
+
+        self.assertEqual(local_wpt.test_patch('dummy patch'), (True, ''))
+
+    def test_test_patch_empty_diff(self):
+        host = MockHost()
+        host.executive = mock_git_commands({
+            'apply': '',
+            'add': '',
+            'diff': '',
+            'reset': '',
+            'clean': '',
+            'checkout': '',
+        }, strict=True)
+        local_wpt = LocalWPT(host, 'token')
+
+        self.assertEqual(local_wpt.test_patch('dummy patch'), (False, ''))
+
+    def test_test_patch_error(self):
+        def _run_fn(args):
+            if args[0] == 'git' and args[1] == 'apply':
+                raise ScriptError('MOCK failed applying patch')
+            return ''
+
+        host = MockHost()
+        host.executive = MockExecutive(run_command_fn=_run_fn)
+        local_wpt = LocalWPT(host, 'token')
+
+        self.assertEqual(local_wpt.test_patch('dummy patch'), (False, 'MOCK failed applying patch'))

third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_exporter.py

diff --git a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_exporter.py b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_exporter.py
index 5f2fed3..7335572c 100644
--- a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_exporter.py
+++ b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_exporter.py
@@ -38,7 +38,9 @@
         open_gerrit_cls = self.gerrit.query_exportable_open_cls()
         self.process_gerrit_cls(open_gerrit_cls)
 
-        exportable_commits = self.get_exportable_commits()
+        exportable_commits, errors = self.get_exportable_commits()
+        for error in errors:
+            _log.warn(error)
         for exportable_commit in exportable_commits:
             pull_request = self.wpt_github.pr_for_chromium_commit(exportable_commit)
 
@@ -153,9 +155,13 @@
         updating = bool(pull_request)
         action_str = 'updating' if updating else 'creating'
 
-        if self.local_wpt.test_patch(patch) == '':
-            _log.error('Gerrit CL patch did not apply cleanly.')
-            _log.error('First 500 characters of patch: %s', patch[0:500])
+        success, message = self.local_wpt.test_patch(patch)
+        if not success:
+            _log.error('Gerrit CL patch did not apply cleanly:')
+            _log.error(message)
+            _log.error('First 500 characters of patch: << END_OF_PATCH_EXCERPT')
+            _log.error(patch[0:500])
+            _log.error('END_OF_PATCH_EXCERPT')
             return
 
         if self.dry_run:

third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_exporter_unittest.py

diff --git a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_exporter_unittest.py b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_exporter_unittest.py
index e966301..03f4e89 100644
--- a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_exporter_unittest.py
+++ b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_exporter_unittest.py
@@ -32,11 +32,11 @@
             PullRequest(title='title1', number=1234, body='', state='open', labels=[]),
         ])
         test_exporter.gerrit = MockGerritAPI(host, 'gerrit-username', 'gerrit-token')
-        test_exporter.get_exportable_commits = lambda: [
+        test_exporter.get_exportable_commits = lambda: ([
             ChromiumCommit(host, position='refs/heads/master@{#458475}'),
             ChromiumCommit(host, position='refs/heads/master@{#458476}'),
             ChromiumCommit(host, position='refs/heads/master@{#458477}'),
-        ]
+        ], [])
         test_exporter.run()
 
         self.assertEqual(test_exporter.wpt_github.calls, [
@@ -133,12 +133,12 @@
             ),
         ], unsuccessful_merge_index=0)
         test_exporter.gerrit = MockGerritAPI(host, 'gerrit-username', 'gerrit-token')
-        test_exporter.get_exportable_commits = lambda: [
+        test_exporter.get_exportable_commits = lambda: ([
             MockChromiumCommit(host, position='refs/heads/master@{#458475}', change_id='I0005'),
             MockChromiumCommit(host, position='refs/heads/master@{#458476}', change_id='I0476'),
             MockChromiumCommit(host, position='refs/heads/master@{#458477}', change_id='Idead'),
             MockChromiumCommit(host, position='refs/heads/master@{#458478}', change_id='I0118'),
-        ]
+        ], [])
         test_exporter.run()
         self.assertEqual(test_exporter.wpt_github.calls, [
             'pr_for_chromium_commit',
@@ -166,7 +166,7 @@
         test_exporter = TestExporter(host, 'gh-username', 'gh-token', gerrit_user=None,
                                      gerrit_token=None, dry_run=False)
         test_exporter.wpt_github = MockWPTGitHub(pull_requests=[])
-        test_exporter.get_exportable_commits = lambda: []
+        test_exporter.get_exportable_commits = lambda: ([], [])
         test_exporter.gerrit = MockGerritAPI(host, 'gerrit-username', 'gerrit-token')
         test_exporter.gerrit.get = lambda path, raw: base64.b64encode('sample diff')  # pylint: disable=unused-argument
         test_exporter.gerrit.query_exportable_open_cls = lambda: [
@@ -204,7 +204,7 @@
                         body='description\nWPT-Export-Revision: 1',
                         state='open', labels=[]),
         ])
-        test_exporter.get_exportable_commits = lambda: []
+        test_exporter.get_exportable_commits = lambda: ([], [])
         test_exporter.gerrit = MockGerritAPI(host, 'gerrit-username', 'gerrit-token')
         test_exporter.gerrit.query_exportable_open_cls = lambda: [
             GerritCL(data={
@@ -234,7 +234,7 @@
                         body='description\nWPT-Export-Revision: 1',
                         state='open', labels=[]),
         ])
-        test_exporter.get_exportable_commits = lambda: []
+        test_exporter.get_exportable_commits = lambda: ([], [])
         test_exporter.gerrit = MockGerritAPI(host, 'gerrit-username', 'gerrit-token')
         test_exporter.gerrit.get = lambda path, raw: base64.b64encode('sample diff')  # pylint: disable=unused-argument
         test_exporter.gerrit.query_exportable_open_cls = lambda: [
@@ -283,9 +283,9 @@
                         body='description\nWPT-Export-Revision: 9\nChange-Id: decafbad',
                         state='open', labels=['do not merge yet']),
         ])
-        test_exporter.get_exportable_commits = lambda: [
+        test_exporter.get_exportable_commits = lambda: ([
             ChromiumCommit(host, sha='c881563d734a86f7d9cd57ac509653a61c45c240'),
-        ]
+        ], [])
         test_exporter.gerrit = MockGerritAPI(host, 'gerrit-username', 'gerrit-token')
         test_exporter.gerrit.query_exportable_open_cls = lambda: []
         test_exporter.run()
@@ -305,7 +305,7 @@
         test_exporter = TestExporter(host, 'gh-username', 'gh-token', gerrit_user=None,
                                      gerrit_token=None, dry_run=False)
         test_exporter.wpt_github = MockWPTGitHub(pull_requests=[])
-        test_exporter.get_exportable_commits = lambda: []
+        test_exporter.get_exportable_commits = lambda: ([], [])
         test_exporter.gerrit = MockGerritAPI(host, 'gerrit-username', 'gerrit-token')
         test_exporter.gerrit.get = lambda path, raw: base64.b64encode('sample diff')  # pylint: disable=unused-argument
         test_exporter.gerrit.query_exportable_open_cls = lambda: [

third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer.py

diff --git a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer.py b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer.py
index 90495e0c..4bffc342 100644
--- a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer.py
+++ b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer.py
@@ -240,7 +240,8 @@
             A list of commits applied (could be empty), or None if any
             of the patches could not be applied cleanly.
         """
-        commits = self.exportable_but_not_exported_commits(local_wpt)
+        # Ignore patch failures when importing. Exporter will report them.
+        commits, _ = self.exportable_but_not_exported_commits(local_wpt)
         for commit in commits:
             _log.info('Applying exportable commit locally:')
             _log.info(commit.url())
@@ -253,8 +254,8 @@
                 _log.info('PR: https://github.com/w3c/web-platform-tests/pull/%d', pull_request.number)
             else:
                 _log.warning('No pull request found.')
-            applied = local_wpt.apply_patch(commit.format_patch())
-            if not applied:
+            error = local_wpt.apply_patch(commit.format_patch())
+            if error:
                 return None
             self.run(
                 ['git', 'commit', '--all', '-F', '-'],
@@ -263,7 +264,8 @@
         return commits
 
     def exportable_but_not_exported_commits(self, local_wpt):
-        """Returns a list of commits that would be clobbered by importer."""
+        """Returns a list of commits that would be clobbered by importer
+        and a list of error messages for patches failing to apply cleanly."""
         return exportable_commits_over_last_n_commits(self.host, local_wpt, self.wpt_github)
 
     def _generate_manifest(self):

third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer_unittest.py

diff --git a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer_unittest.py b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer_unittest.py
index bed480ef..83129c58 100644
--- a/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer_unittest.py
+++ b/third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer_unittest.py
@@ -116,7 +116,7 @@
                 '+++ b/third_party/WebKit/LayoutTests/external/wpt/css/css-ui-3/outline-004.html\n'
                 '@@ -20,7 +20,7 @@\n'
                 '...'))
-        importer.exportable_but_not_exported_commits = lambda _: [fake_commit]
+        importer.exportable_but_not_exported_commits = lambda _: ([fake_commit], [])
         applied = importer.apply_exportable_commits_locally(LocalWPT(host))
         self.assertEqual(applied, [fake_commit])
         self.assertEqual(host.executive.full_calls, [
@@ -145,9 +145,9 @@
         wpt_github = MockWPTGitHub(pull_requests=[])
         importer = TestImporter(host, wpt_github=wpt_github)
         commit = MockChromiumCommit(host, subject='My fake commit')
-        importer.exportable_but_not_exported_commits = lambda _: [commit]
+        importer.exportable_but_not_exported_commits = lambda _: ([commit], [])
         local_wpt = LocalWPT(host)
-        local_wpt.apply_patch = lambda _: None  # Failure to apply patch.
+        local_wpt.apply_patch = lambda _: 'Failed'  # Failure to apply patch.
         applied = importer.apply_exportable_commits_locally(local_wpt)
         self.assertIsNone(applied)
 

third_party/WebKit/public/blink_typemaps.gni

diff --git a/third_party/WebKit/public/blink_typemaps.gni b/third_party/WebKit/public/blink_typemaps.gni
index 1e0424c..7bb342b 100644
--- a/third_party/WebKit/public/blink_typemaps.gni
+++ b/third_party/WebKit/public/blink_typemaps.gni
@@ -4,13 +4,13 @@
 
 typemaps = [
   "//cc/ipc/begin_frame_args_for_blink.typemap",
-  "//services/viz/public/cpp/compositing/compositor_frame_for_blink.typemap",
   "//cc/ipc/frame_sink_id.typemap",
   "//cc/ipc/local_surface_id.typemap",
   "//cc/ipc/surface_id.typemap",
-  "//cc/ipc/surface_info.typemap",
   "//cc/ipc/surface_sequence.typemap",
   "//gpu/ipc/common/mailbox_holder_for_blink.typemap",
   "//gpu/ipc/common/sync_token.typemap",
+  "//services/viz/public/cpp/compositing/compositor_frame_for_blink.typemap",
   "//services/viz/public/cpp/compositing/returned_resource.typemap",
+  "//services/viz/public/cpp/compositing/surface_info.typemap",
 ]

third_party/WebKit/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom

diff --git a/third_party/WebKit/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom b/third_party/WebKit/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom
index 966de20..870a31817 100644
--- a/third_party/WebKit/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom
+++ b/third_party/WebKit/public/platform/modules/offscreencanvas/offscreen_canvas_surface.mojom
@@ -6,10 +6,9 @@
 
 import "cc/ipc/frame_sink_id.mojom";
 import "cc/ipc/surface_id.mojom";
-import "cc/ipc/surface_info.mojom";
 import "cc/ipc/surface_sequence.mojom";
-import "services/viz/compositing/privileged/interfaces/frame_sink_manager.mojom";
 import "services/viz/public/interfaces/compositing/compositor_frame_sink.mojom";
+import "services/viz/public/interfaces/compositing/surface_info.mojom";
 
 interface OffscreenCanvasSurface {
   Require(cc.mojom.SurfaceId surface_id, cc.mojom.SurfaceSequence sequence);
@@ -17,7 +16,7 @@
 };
 
 interface OffscreenCanvasSurfaceClient {
-  OnFirstSurfaceActivation(cc.mojom.SurfaceInfo surface_info);
+  OnFirstSurfaceActivation(viz.mojom.SurfaceInfo surface_info);
 };
 
 // Creates OffscreenCanvasSurface and CompositorFrameSink instances for use

third_party/libvpx/README.chromium

diff --git a/third_party/libvpx/README.chromium b/third_party/libvpx/README.chromium
index cf2675e3..42518755 100644
--- a/third_party/libvpx/README.chromium
+++ b/third_party/libvpx/README.chromium
@@ -5,9 +5,9 @@
 License File: source/libvpx/LICENSE
 Security Critical: yes
 
-Date: Tuesday August 01 2017
+Date: Friday August 04 2017
 Branch: master
-Commit: c22b17dcefe05981918e4b7d0b6527c27e9ceda8
+Commit: cbb83ba4aa99b40b0b4a2a407bfd6d0d8be87d1f
 
 Description:
 Contains the sources used to compile libvpx binaries used by Google Chrome and

third_party/libvpx/generate_gni.sh

diff --git a/third_party/libvpx/generate_gni.sh b/third_party/libvpx/generate_gni.sh
index 6e0f0de..84ff8e42 100755
--- a/third_party/libvpx/generate_gni.sh
+++ b/third_party/libvpx/generate_gni.sh
@@ -241,6 +241,8 @@
     $BASE_DIR/$LIBVPX_SRC_DIR/vp8/common/rtcd_defs.pl \
     > $BASE_DIR/$LIBVPX_CONFIG_DIR/$1/vp8_rtcd.h
 
+  clang-format -i $BASE_DIR/$LIBVPX_CONFIG_DIR/$1/vp8_rtcd.h
+
   $BASE_DIR/$LIBVPX_SRC_DIR/build/make/rtcd.pl \
     --arch=$2 \
     --sym=vp9_rtcd $DISABLE_AVX $3 \
@@ -248,6 +250,8 @@
     $BASE_DIR/$LIBVPX_SRC_DIR/vp9/common/vp9_rtcd_defs.pl \
     > $BASE_DIR/$LIBVPX_CONFIG_DIR/$1/vp9_rtcd.h
 
+  clang-format -i $BASE_DIR/$LIBVPX_CONFIG_DIR/$1/vp9_rtcd.h
+
   $BASE_DIR/$LIBVPX_SRC_DIR/build/make/rtcd.pl \
     --arch=$2 \
     --sym=vpx_scale_rtcd $DISABLE_AVX $3 \
@@ -255,6 +259,8 @@
     $BASE_DIR/$LIBVPX_SRC_DIR/vpx_scale/vpx_scale_rtcd.pl \
     > $BASE_DIR/$LIBVPX_CONFIG_DIR/$1/vpx_scale_rtcd.h
 
+  clang-format -i $BASE_DIR/$LIBVPX_CONFIG_DIR/$1/vpx_scale_rtcd.h
+
   $BASE_DIR/$LIBVPX_SRC_DIR/build/make/rtcd.pl \
     --arch=$2 \
     --sym=vpx_dsp_rtcd $DISABLE_AVX $3 \
@@ -262,6 +268,8 @@
     $BASE_DIR/$LIBVPX_SRC_DIR/vpx_dsp/vpx_dsp_rtcd_defs.pl \
     > $BASE_DIR/$LIBVPX_CONFIG_DIR/$1/vpx_dsp_rtcd.h
 
+  clang-format -i $BASE_DIR/$LIBVPX_CONFIG_DIR/$1/vpx_dsp_rtcd.h
+
   rm -rf $BASE_DIR/$TEMP_DIR/libvpx.config
 }
 

third_party/libvpx/libvpx_srcs.gni

diff --git a/third_party/libvpx/libvpx_srcs.gni b/third_party/libvpx/libvpx_srcs.gni
index a975c9f..1a3292f06 100644
--- a/third_party/libvpx/libvpx_srcs.gni
+++ b/third_party/libvpx/libvpx_srcs.gni
@@ -457,7 +457,6 @@
   "//third_party/libvpx/source/libvpx/vpx_dsp/x86/sad4d_avx2.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/x86/sad_avx2.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/x86/variance_avx2.c",
-  "//third_party/libvpx/source/libvpx/vpx_dsp/x86/variance_impl_avx2.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/x86/vpx_subpixel_8t_intrin_avx2.c",
 ]
 libvpx_srcs_x86_64 = [
@@ -921,7 +920,6 @@
   "//third_party/libvpx/source/libvpx/vpx_dsp/x86/sad4d_avx2.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/x86/sad_avx2.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/x86/variance_avx2.c",
-  "//third_party/libvpx/source/libvpx/vpx_dsp/x86/variance_impl_avx2.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/x86/vpx_subpixel_8t_intrin_avx2.c",
 ]
 libvpx_srcs_arm = [
@@ -1588,6 +1586,7 @@
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/idct_neon.h",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/intrapred_neon.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/mem_neon.h",
+  "//third_party/libvpx/source/libvpx/vpx_dsp/arm/quantize_neon.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/sad4d_neon.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/sad_neon.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/subpel_variance_neon.c",
@@ -2076,6 +2075,7 @@
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/idct8x8_1_add_neon.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/idct8x8_add_neon.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/intrapred_neon.c",
+  "//third_party/libvpx/source/libvpx/vpx_dsp/arm/quantize_neon.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/sad4d_neon.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/sad_neon.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/subpel_variance_neon.c",
@@ -2409,6 +2409,7 @@
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/intrapred_neon.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/loopfilter_neon.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/mem_neon.h",
+  "//third_party/libvpx/source/libvpx/vpx_dsp/arm/quantize_neon.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/sad4d_neon.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/sad_neon.c",
   "//third_party/libvpx/source/libvpx/vpx_dsp/arm/subpel_variance_neon.c",

third_party/libvpx/source/config/ios/arm-neon/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/ios/arm-neon/vp8_rtcd.h b/third_party/libvpx/source/config/ios/arm-neon/vp8_rtcd.h
index 6a7f92c..c6222d0 100644
--- a/third_party/libvpx/source/config/ios/arm-neon/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/ios/arm-neon/vp8_rtcd.h
@@ -26,174 +26,455 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+void vp8_bilinear_predict16x16_neon(unsigned char* src,
+                                    int src_pitch,
+                                    int xofst,
+                                    int yofst,
+                                    unsigned char* dst,
+                                    int dst_pitch);
 #define vp8_bilinear_predict16x16 vp8_bilinear_predict16x16_neon
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict4x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict4x4_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_bilinear_predict4x4 vp8_bilinear_predict4x4_neon
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x4_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_bilinear_predict8x4 vp8_bilinear_predict8x4_neon
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x8_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_bilinear_predict8x8 vp8_bilinear_predict8x8_neon
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
 #define vp8_block_error vp8_block_error_c
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem16x16_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+void vp8_copy_mem16x16_neon(unsigned char* src,
+                            int src_pitch,
+                            unsigned char* dst,
+                            int dst_pitch);
 #define vp8_copy_mem16x16 vp8_copy_mem16x16_neon
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x4_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x4_neon(unsigned char* src,
+                          int src_pitch,
+                          unsigned char* dst,
+                          int dst_pitch);
 #define vp8_copy_mem8x4 vp8_copy_mem8x4_neon
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x8_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x8_neon(unsigned char* src,
+                          int src_pitch,
+                          unsigned char* dst,
+                          int dst_pitch);
 #define vp8_copy_mem8x8 vp8_copy_mem8x8_neon
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-void vp8_dc_only_idct_add_neon(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_dc_only_idct_add_neon(short input,
+                               unsigned char* pred,
+                               int pred_stride,
+                               unsigned char* dst,
+                               int dst_stride);
 #define vp8_dc_only_idct_add vp8_dc_only_idct_add_neon
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_neon(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
+int vp8_denoiser_filter_neon(unsigned char* mc_running_avg_y,
+                             int mc_avg_y_stride,
+                             unsigned char* running_avg_y,
+                             int avg_y_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
 #define vp8_denoiser_filter vp8_denoiser_filter_neon
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_uv_neon(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+int vp8_denoiser_filter_uv_neon(unsigned char* mc_running_avg,
+                                int mc_avg_stride,
+                                unsigned char* running_avg,
+                                int avg_stride,
+                                unsigned char* sig,
+                                int sig_stride,
+                                unsigned int motion_magnitude,
+                                int increase_denoising);
 #define vp8_denoiser_filter_uv vp8_denoiser_filter_uv_neon
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
-void vp8_dequant_idct_add_neon(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
+void vp8_dequant_idct_add_neon(short* input,
+                               short* dq,
+                               unsigned char* output,
+                               int stride);
 #define vp8_dequant_idct_add vp8_dequant_idct_add_neon
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-void vp8_dequant_idct_add_uv_block_neon(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
+void vp8_dequant_idct_add_uv_block_neon(short* q,
+                                        short* dq,
+                                        unsigned char* dst_u,
+                                        unsigned char* dst_v,
+                                        int stride,
+                                        char* eobs);
 #define vp8_dequant_idct_add_uv_block vp8_dequant_idct_add_uv_block_neon
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-void vp8_dequant_idct_add_y_block_neon(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
+void vp8_dequant_idct_add_y_block_neon(short* q,
+                                       short* dq,
+                                       unsigned char* dst,
+                                       int stride,
+                                       char* eobs);
 #define vp8_dequant_idct_add_y_block vp8_dequant_idct_add_y_block_neon
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
-void vp8_dequantize_b_neon(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
+void vp8_dequantize_b_neon(struct blockd*, short* dqc);
 #define vp8_dequantize_b vp8_dequantize_b_neon
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
 #define vp8_diamond_search_sad vp8_diamond_search_sad_c
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
-void vp8_fast_quantize_b_neon(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
+void vp8_fast_quantize_b_neon(struct block*, struct blockd*);
 #define vp8_fast_quantize_b vp8_fast_quantize_b_neon
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp8_filter_by_weight16x16 vp8_filter_by_weight16x16_c
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight8x8 vp8_filter_by_weight8x8_c
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
 #define vp8_full_search_sad vp8_full_search_sad_c
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bh_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bh_neon(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
 #define vp8_loop_filter_bh vp8_loop_filter_bh_neon
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bv_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bv_neon(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
 #define vp8_loop_filter_bv vp8_loop_filter_bv_neon
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbh_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbh_neon(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbh vp8_loop_filter_mbh_neon
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbv_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbv_neon(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbv vp8_loop_filter_mbv_neon
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bhs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bhs_neon(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_bh vp8_loop_filter_bhs_neon
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bvs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bvs_neon(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_bv vp8_loop_filter_bvs_neon
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_mbhs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
+void vp8_loop_filter_mbhs_neon(unsigned char* y,
+                               int ystride,
+                               const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbh vp8_loop_filter_mbhs_neon
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_mbvs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
+void vp8_loop_filter_mbvs_neon(unsigned char* y,
+                               int ystride,
+                               const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbv vp8_loop_filter_mbvs_neon
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
 #define vp8_mbblock_error vp8_mbblock_error_c
 
-int vp8_mbuverror_c(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
 #define vp8_mbuverror vp8_mbuverror_c
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
 #define vp8_refining_search_sad vp8_refining_search_sad_c
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
 #define vp8_regular_quantize_b vp8_regular_quantize_b_c
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct4x4_neon(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct4x4_neon(short* input, short* output, int pitch);
 #define vp8_short_fdct4x4 vp8_short_fdct4x4_neon
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct8x4_neon(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct8x4_neon(short* input, short* output, int pitch);
 #define vp8_short_fdct8x4 vp8_short_fdct8x4_neon
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-void vp8_short_idct4x4llm_neon(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_short_idct4x4llm_neon(short* input,
+                               unsigned char* pred,
+                               int pitch,
+                               unsigned char* dst,
+                               int dst_stride);
 #define vp8_short_idct4x4llm vp8_short_idct4x4llm_neon
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
-void vp8_short_inv_walsh4x4_neon(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
+void vp8_short_inv_walsh4x4_neon(short* input, short* output);
 #define vp8_short_inv_walsh4x4 vp8_short_inv_walsh4x4_neon
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
-void vp8_short_walsh4x4_neon(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
+void vp8_short_walsh4x4_neon(short* input, short* output, int pitch);
 #define vp8_short_walsh4x4 vp8_short_walsh4x4_neon
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict16x16_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_sixtap_predict16x16 vp8_sixtap_predict16x16_neon
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict4x4_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
 #define vp8_sixtap_predict4x4 vp8_sixtap_predict4x4_neon
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x4_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
 #define vp8_sixtap_predict8x4 vp8_sixtap_predict8x4_neon
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x8_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
 #define vp8_sixtap_predict8x8 vp8_sixtap_predict8x8_neon
 
 void vp8_rtcd(void);
@@ -202,12 +483,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/ios/arm-neon/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/ios/arm-neon/vp9_rtcd.h b/third_party/libvpx/source/config/ios/arm-neon/vp9_rtcd.h
index a0f86ea..2ff413b 100644
--- a/third_party/libvpx/source/config/ios/arm-neon/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/ios/arm-neon/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,64 +30,192 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
 #define vp9_block_error vp9_block_error_c
 
-int64_t vp9_block_error_fp_c(const int16_t *coeff, const int16_t *dqcoeff, int block_size);
-int64_t vp9_block_error_fp_neon(const int16_t *coeff, const int16_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const int16_t* coeff,
+                             const int16_t* dqcoeff,
+                             int block_size);
+int64_t vp9_block_error_fp_neon(const int16_t* coeff,
+                                const int16_t* dqcoeff,
+                                int block_size);
 #define vp9_block_error_fp vp9_block_error_fp_neon
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-int vp9_denoiser_filter_neon(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
+int vp9_denoiser_filter_neon(const uint8_t* sig,
+                             int sig_stride,
+                             const uint8_t* mc_avg,
+                             int mc_avg_stride,
+                             uint8_t* avg,
+                             int avg_stride,
+                             int increase_denoising,
+                             BLOCK_SIZE bs,
+                             int motion_magnitude);
 #define vp9_denoiser_filter vp9_denoiser_filter_neon
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
 #define vp9_diamond_search_sad vp9_diamond_search_sad_c
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_fdct8x8_quant_neon(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+void vp9_fdct8x8_quant_neon(const int16_t* input,
+                            int stride,
+                            tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vp9_fdct8x8_quant vp9_fdct8x8_quant_neon
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
 #define vp9_fht16x16 vp9_fht16x16_c
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht4x4 vp9_fht4x4_c
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht8x8 vp9_fht8x8_c
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp9_filter_by_weight16x16 vp9_filter_by_weight16x16_c
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp9_filter_by_weight8x8 vp9_filter_by_weight8x8_c
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_fwht4x4 vp9_fwht4x4_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
 #define vp9_iht16x16_256_add vp9_iht16x16_256_add_c
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht4x4_16_add_neon(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht4x4_16_add_neon(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
 #define vp9_iht4x4_16_add vp9_iht4x4_16_add_neon
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht8x8_64_add_neon(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht8x8_64_add_neon(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
 #define vp9_iht8x8_64_add vp9_iht8x8_64_add_neon
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_neon(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
+void vp9_quantize_fp_neon(const tran_low_t* coeff_ptr,
+                          intptr_t n_coeffs,
+                          int skip_block,
+                          const int16_t* round_ptr,
+                          const int16_t* quant_ptr,
+                          tran_low_t* qcoeff_ptr,
+                          tran_low_t* dqcoeff_ptr,
+                          const int16_t* dequant_ptr,
+                          uint16_t* eob_ptr,
+                          const int16_t* scan,
+                          const int16_t* iscan);
 #define vp9_quantize_fp vp9_quantize_fp_neon
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vp9_quantize_fp_32x32 vp9_quantize_fp_32x32_c
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
 #define vp9_scale_and_extend_frame vp9_scale_and_extend_frame_c
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
 #define vp9_temporal_filter_apply vp9_temporal_filter_apply_c
 
 void vp9_rtcd(void);
@@ -96,12 +224,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/ios/arm-neon/vpx_config.asm

diff --git a/third_party/libvpx/source/config/ios/arm-neon/vpx_config.asm b/third_party/libvpx/source/config/ios/arm-neon/vpx_config.asm
index b1bf106..3cdd43c 100644
--- a/third_party/libvpx/source/config/ios/arm-neon/vpx_config.asm
+++ b/third_party/libvpx/source/config/ios/arm-neon/vpx_config.asm
@@ -24,6 +24,7 @@
 .set HAVE_AVX ,  0
 .set HAVE_AVX2 ,  0
 .set HAVE_VSX ,  0
+.set HAVE_MMI ,  0
 .set HAVE_VPX_PORTS ,  1
 .set HAVE_PTHREAD_H ,  1
 .set HAVE_UNISTD_H ,  0

third_party/libvpx/source/config/ios/arm-neon/vpx_config.h

diff --git a/third_party/libvpx/source/config/ios/arm-neon/vpx_config.h b/third_party/libvpx/source/config/ios/arm-neon/vpx_config.h
index b33278b..a6042f62 100644
--- a/third_party/libvpx/source/config/ios/arm-neon/vpx_config.h
+++ b/third_party/libvpx/source/config/ios/arm-neon/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 0
 #define HAVE_AVX2 0
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/ios/arm-neon/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/ios/arm-neon/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/ios/arm-neon/vpx_dsp_rtcd.h
index c694f53..ae6787f 100644
--- a/third_party/libvpx/source/config/ios/arm-neon/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/ios/arm-neon/vpx_dsp_rtcd.h
@@ -14,843 +14,2400 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
-unsigned int vpx_avg_4x4_neon(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
+unsigned int vpx_avg_4x4_neon(const uint8_t*, int p);
 #define vpx_avg_4x4 vpx_avg_4x4_neon
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
-unsigned int vpx_avg_8x8_neon(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
+unsigned int vpx_avg_8x8_neon(const uint8_t*, int p);
 #define vpx_avg_8x8 vpx_avg_8x8_neon
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-void vpx_comp_avg_pred_neon(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
+void vpx_comp_avg_pred_neon(uint8_t* comp_pred,
+                            const uint8_t* pred,
+                            int width,
+                            int height,
+                            const uint8_t* ref,
+                            int ref_stride);
 #define vpx_comp_avg_pred vpx_comp_avg_pred_neon
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_convolve8_neon(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_convolve8 vpx_convolve8_neon
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avg_neon(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_convolve8_avg vpx_convolve8_avg_neon
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_avg_horiz_neon(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 #define vpx_convolve8_avg_horiz vpx_convolve8_avg_horiz_neon
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_avg_vert_neon(const uint8_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h);
 #define vpx_convolve8_avg_vert vpx_convolve8_avg_vert_neon
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+void vpx_convolve8_horiz_neon(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
 #define vpx_convolve8_horiz vpx_convolve8_horiz_neon
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
+void vpx_convolve8_vert_neon(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
 #define vpx_convolve8_vert vpx_convolve8_vert_neon
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_avg_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve_avg_neon(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_convolve_avg vpx_convolve_avg_neon
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_copy_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve_copy_neon(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_convolve_copy vpx_convolve_copy_neon
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d135_predictor_16x16_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_neon
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d135_predictor_32x32_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_neon
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d135_predictor_4x4_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_neon
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d135_predictor_8x8_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_neon
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_16x16 vpx_d153_predictor_16x16_c
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_32x32 vpx_d153_predictor_32x32_c
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_4x4 vpx_d153_predictor_4x4_c
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_8x8 vpx_d153_predictor_8x8_c
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_16x16 vpx_d207_predictor_16x16_c
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_32x32 vpx_d207_predictor_32x32_c
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_4x4 vpx_d207_predictor_4x4_c
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_8x8 vpx_d207_predictor_8x8_c
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_16x16_neon(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_d45_predictor_16x16 vpx_d45_predictor_16x16_neon
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_32x32_neon(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_d45_predictor_32x32 vpx_d45_predictor_32x32_neon
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_4x4_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d45_predictor_4x4 vpx_d45_predictor_4x4_neon
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_8x8_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d45_predictor_8x8 vpx_d45_predictor_8x8_neon
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_16x16 vpx_d63_predictor_16x16_c
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_32x32 vpx_d63_predictor_32x32_c
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_4x4 vpx_d63_predictor_4x4_c
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_8x8 vpx_d63_predictor_8x8_c
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_16x16_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_128_predictor_16x16 vpx_dc_128_predictor_16x16_neon
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_32x32_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_128_predictor_32x32 vpx_dc_128_predictor_32x32_neon
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_4x4_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_128_predictor_4x4 vpx_dc_128_predictor_4x4_neon
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_8x8_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_128_predictor_8x8 vpx_dc_128_predictor_8x8_neon
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_16x16_neon(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
 #define vpx_dc_left_predictor_16x16 vpx_dc_left_predictor_16x16_neon
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_32x32_neon(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
 #define vpx_dc_left_predictor_32x32 vpx_dc_left_predictor_32x32_neon
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_4x4_neon(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
 #define vpx_dc_left_predictor_4x4 vpx_dc_left_predictor_4x4_neon
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_8x8_neon(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
 #define vpx_dc_left_predictor_8x8 vpx_dc_left_predictor_8x8_neon
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_16x16_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_predictor_16x16 vpx_dc_predictor_16x16_neon
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_32x32_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_predictor_32x32 vpx_dc_predictor_32x32_neon
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_4x4_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_dc_predictor_4x4 vpx_dc_predictor_4x4_neon
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_8x8_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_dc_predictor_8x8 vpx_dc_predictor_8x8_neon
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_16x16_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_top_predictor_16x16 vpx_dc_top_predictor_16x16_neon
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_32x32_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_top_predictor_32x32 vpx_dc_top_predictor_32x32_neon
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_4x4_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_top_predictor_4x4 vpx_dc_top_predictor_4x4_neon
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_8x8_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_top_predictor_8x8 vpx_dc_top_predictor_8x8_neon
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16 vpx_fdct16x16_neon
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16_1 vpx_fdct16x16_1_neon
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32 vpx_fdct32x32_neon
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_1 vpx_fdct32x32_1_neon
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_rd_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_rd_neon(const int16_t* input,
+                           tran_low_t* output,
+                           int stride);
 #define vpx_fdct32x32_rd vpx_fdct32x32_rd_neon
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4 vpx_fdct4x4_neon
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4_1 vpx_fdct4x4_1_neon
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8 vpx_fdct8x8_neon
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8_1 vpx_fdct8x8_1_neon
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
+void vpx_get16x16var_neon(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
 #define vpx_get16x16var vpx_get16x16var_neon
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
-unsigned int vpx_get4x4sse_cs_neon(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
+unsigned int vpx_get4x4sse_cs_neon(const unsigned char* src_ptr,
+                                   int source_stride,
+                                   const unsigned char* ref_ptr,
+                                   int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_neon
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get8x8var_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
+void vpx_get8x8var_neon(const uint8_t* src_ptr,
+                        int source_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        unsigned int* sse,
+                        int* sum);
 #define vpx_get8x8var vpx_get8x8var_neon
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
 #define vpx_get_mb_ss vpx_get_mb_ss_c
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_16x16_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_h_predictor_16x16 vpx_h_predictor_16x16_neon
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_32x32_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_h_predictor_32x32 vpx_h_predictor_32x32_neon
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_4x4_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_h_predictor_4x4 vpx_h_predictor_4x4_neon
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_8x8_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_h_predictor_8x8 vpx_h_predictor_8x8_neon
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
-void vpx_hadamard_16x16_neon(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          int16_t* coeff);
+void vpx_hadamard_16x16_neon(const int16_t* src_diff,
+                             int src_stride,
+                             int16_t* coeff);
 #define vpx_hadamard_16x16 vpx_hadamard_16x16_neon
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
-void vpx_hadamard_8x8_neon(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        int16_t* coeff);
+void vpx_hadamard_8x8_neon(const int16_t* src_diff,
+                           int src_stride,
+                           int16_t* coeff);
 #define vpx_hadamard_8x8 vpx_hadamard_8x8_neon
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_10_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_10_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct16x16_10_add vpx_idct16x16_10_add_neon
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_1_add_neon(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct16x16_1_add vpx_idct16x16_1_add_neon
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_256_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct16x16_256_add_neon(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
 #define vpx_idct16x16_256_add vpx_idct16x16_256_add_neon
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_38_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_38_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct16x16_38_add vpx_idct16x16_38_add_neon
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+void vpx_idct32x32_1024_add_neon(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
 #define vpx_idct32x32_1024_add vpx_idct32x32_1024_add_neon
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_135_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct32x32_135_add_neon(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
 #define vpx_idct32x32_135_add vpx_idct32x32_135_add_neon
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_1_add_neon(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct32x32_1_add vpx_idct32x32_1_add_neon
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_34_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct32x32_34_add vpx_idct32x32_34_add_neon
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_16_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_16_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct4x4_16_add vpx_idct4x4_16_add_neon
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_1_add_neon(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_1_add vpx_idct4x4_1_add_neon
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_12_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct8x8_12_add vpx_idct8x8_12_add_neon
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_1_add_neon(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_1_add vpx_idct8x8_1_add_neon
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_64_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_64_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct8x8_64_add vpx_idct8x8_64_add_neon
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
-int16_t vpx_int_pro_col_neon(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
+int16_t vpx_int_pro_col_neon(const uint8_t* ref, const int width);
 #define vpx_int_pro_col vpx_int_pro_col_neon
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-void vpx_int_pro_row_neon(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
+void vpx_int_pro_row_neon(int16_t* hbuf,
+                          const uint8_t* ref,
+                          const int ref_stride,
+                          const int height);
 #define vpx_int_pro_row vpx_int_pro_row_neon
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_16_add vpx_iwht4x4_16_add_c
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+void vpx_lpf_horizontal_16_neon(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
 #define vpx_lpf_horizontal_16 vpx_lpf_horizontal_16_neon
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_neon(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
 #define vpx_lpf_horizontal_16_dual vpx_lpf_horizontal_16_dual_neon
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_4_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_4_neon(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
 #define vpx_lpf_horizontal_4 vpx_lpf_horizontal_4_neon
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_4_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_4_dual_neon(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
 #define vpx_lpf_horizontal_4_dual vpx_lpf_horizontal_4_dual_neon
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_8_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_8_neon(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
 #define vpx_lpf_horizontal_8 vpx_lpf_horizontal_8_neon
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_8_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_8_dual_neon(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
 #define vpx_lpf_horizontal_8_dual vpx_lpf_horizontal_8_dual_neon
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
+void vpx_lpf_vertical_16_neon(uint8_t* s,
+                              int pitch,
+                              const uint8_t* blimit,
+                              const uint8_t* limit,
+                              const uint8_t* thresh);
 #define vpx_lpf_vertical_16 vpx_lpf_vertical_16_neon
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_vertical_16_dual_neon(uint8_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh);
 #define vpx_lpf_vertical_16_dual vpx_lpf_vertical_16_dual_neon
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_4_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_4_neon(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_vertical_4 vpx_lpf_vertical_4_neon
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_4_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_4_dual_neon(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
 #define vpx_lpf_vertical_4_dual vpx_lpf_vertical_4_dual_neon
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_8_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_8_neon(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_vertical_8 vpx_lpf_vertical_8_neon
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_8_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_8_dual_neon(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
 #define vpx_lpf_vertical_8_dual vpx_lpf_vertical_8_dual_neon
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_across_ip_neon(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
+void vpx_mbpost_proc_across_ip_neon(unsigned char* dst,
+                                    int pitch,
+                                    int rows,
+                                    int cols,
+                                    int flimit);
 #define vpx_mbpost_proc_across_ip vpx_mbpost_proc_across_ip_neon
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_down_neon(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
+void vpx_mbpost_proc_down_neon(unsigned char* dst,
+                               int pitch,
+                               int rows,
+                               int cols,
+                               int flimit);
 #define vpx_mbpost_proc_down vpx_mbpost_proc_down_neon
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-void vpx_minmax_8x8_neon(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
+void vpx_minmax_8x8_neon(const uint8_t* s,
+                         int p,
+                         const uint8_t* d,
+                         int dp,
+                         int* min,
+                         int* max);
 #define vpx_minmax_8x8 vpx_minmax_8x8_neon
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_neon(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
+unsigned int vpx_mse16x16_neon(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
 #define vpx_mse16x16 vpx_mse16x16_neon
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse16x8 vpx_mse16x8_c
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse8x16 vpx_mse8x16_c
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
 #define vpx_mse8x8 vpx_mse8x8_c
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
 #define vpx_plane_add_noise vpx_plane_add_noise_c
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-void vpx_post_proc_down_and_across_mb_row_neon(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-#define vpx_post_proc_down_and_across_mb_row vpx_post_proc_down_and_across_mb_row_neon
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+void vpx_post_proc_down_and_across_mb_row_neon(unsigned char* src,
+                                               unsigned char* dst,
+                                               int src_pitch,
+                                               int dst_pitch,
+                                               int cols,
+                                               unsigned char* flimits,
+                                               int size);
+#define vpx_post_proc_down_and_across_mb_row \
+  vpx_post_proc_down_and_across_mb_row_neon
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-#define vpx_quantize_b vpx_quantize_b_c
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
+void vpx_quantize_b_neon(const tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* zbin_ptr,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         const int16_t* quant_shift_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+#define vpx_quantize_b vpx_quantize_b_neon
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vpx_quantize_b_32x32 vpx_quantize_b_32x32_c
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x16_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad16x16 vpx_sad16x16_neon
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x16_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad16x16_avg vpx_sad16x16_avg_neon
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x3 vpx_sad16x16x3_c
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x16x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad16x16x4d vpx_sad16x16x4d_neon
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x8 vpx_sad16x16x8_c
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad16x32 vpx_sad16x32_neon
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad16x32_avg vpx_sad16x32_avg_neon
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad16x32x4d vpx_sad16x32x4d_neon
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad16x8_neon(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
 #define vpx_sad16x8 vpx_sad16x8_neon
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad16x8_avg_neon(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
 #define vpx_sad16x8_avg vpx_sad16x8_avg_neon
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x3 vpx_sad16x8x3_c
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x8x4d_neon(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
 #define vpx_sad16x8x4d vpx_sad16x8x4d_neon
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x8 vpx_sad16x8x8_c
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x16_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad32x16 vpx_sad32x16_neon
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad32x16_avg vpx_sad32x16_avg_neon
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x16x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x16x4d vpx_sad32x16x4d_neon
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad32x32 vpx_sad32x32_neon
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad32x32_avg vpx_sad32x32_avg_neon
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x32x4d vpx_sad32x32x4d_neon
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x64_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad32x64 vpx_sad32x64_neon
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad32x64_avg vpx_sad32x64_avg_neon
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x64x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x64x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x64x4d vpx_sad32x64x4d_neon
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x4_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x4_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad4x4 vpx_sad4x4_neon
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x4_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x4_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad4x4_avg vpx_sad4x4_avg_neon
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x3 vpx_sad4x4x3_c
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x4x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad4x4x4d vpx_sad4x4x4d_neon
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x8 vpx_sad4x4x8_c
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x8_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad4x8 vpx_sad4x8_neon
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x8_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad4x8_avg vpx_sad4x8_avg_neon
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x8x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad4x8x4d vpx_sad4x8x4d_neon
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad64x32 vpx_sad64x32_neon
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad64x32_avg vpx_sad64x32_avg_neon
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad64x32x4d vpx_sad64x32x4d_neon
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x64_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad64x64 vpx_sad64x64_neon
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad64x64_avg vpx_sad64x64_avg_neon
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x64x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad64x64x4d vpx_sad64x64x4d_neon
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad8x16_neon(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
 #define vpx_sad8x16 vpx_sad8x16_neon
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad8x16_avg_neon(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
 #define vpx_sad8x16_avg vpx_sad8x16_avg_neon
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x3 vpx_sad8x16x3_c
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad8x16x4d_neon(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
 #define vpx_sad8x16x4d vpx_sad8x16x4d_neon
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x8 vpx_sad8x16x8_c
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x4_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x4_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad8x4 vpx_sad8x4_neon
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x4_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x4_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad8x4_avg vpx_sad8x4_avg_neon
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x4x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x4x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad8x4x4d vpx_sad8x4x4d_neon
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x8_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad8x8 vpx_sad8x8_neon
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x8_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad8x8_avg vpx_sad8x8_avg_neon
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x3 vpx_sad8x8x3_c
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x8x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad8x8x4d vpx_sad8x8x4d_neon
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x8 vpx_sad8x8x8_c
 
-int vpx_satd_c(const int16_t *coeff, int length);
-int vpx_satd_neon(const int16_t *coeff, int length);
+int vpx_satd_c(const int16_t* coeff, int length);
+int vpx_satd_neon(const int16_t* coeff, int length);
 #define vpx_satd vpx_satd_neon
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_scaled_2d vpx_scaled_2d_c
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x16 vpx_sub_pixel_avg_variance16x16_neon
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x32 vpx_sub_pixel_avg_variance16x32_neon
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_neon(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x8 vpx_sub_pixel_avg_variance16x8_neon
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x16 vpx_sub_pixel_avg_variance32x16_neon
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x32 vpx_sub_pixel_avg_variance32x32_neon
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x64 vpx_sub_pixel_avg_variance32x64_neon
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x4 vpx_sub_pixel_avg_variance4x4_neon
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x8 vpx_sub_pixel_avg_variance4x8_neon
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x32 vpx_sub_pixel_avg_variance64x32_neon
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x64 vpx_sub_pixel_avg_variance64x64_neon
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_neon(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x16 vpx_sub_pixel_avg_variance8x16_neon
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x4 vpx_sub_pixel_avg_variance8x4_neon
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x8 vpx_sub_pixel_avg_variance8x8_neon
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance16x16 vpx_sub_pixel_variance16x16_neon
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance16x32 vpx_sub_pixel_variance16x32_neon
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_neon(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
 #define vpx_sub_pixel_variance16x8 vpx_sub_pixel_variance16x8_neon
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance32x16 vpx_sub_pixel_variance32x16_neon
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance32x32 vpx_sub_pixel_variance32x32_neon
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance32x64 vpx_sub_pixel_variance32x64_neon
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance4x4 vpx_sub_pixel_variance4x4_neon
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance4x8 vpx_sub_pixel_variance4x8_neon
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance64x32 vpx_sub_pixel_variance64x32_neon
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance64x64 vpx_sub_pixel_variance64x64_neon
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_neon(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
 #define vpx_sub_pixel_variance8x16 vpx_sub_pixel_variance8x16_neon
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance8x4 vpx_sub_pixel_variance8x4_neon
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance8x8 vpx_sub_pixel_variance8x8_neon
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-void vpx_subtract_block_neon(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
+void vpx_subtract_block_neon(int rows,
+                             int cols,
+                             int16_t* diff_ptr,
+                             ptrdiff_t diff_stride,
+                             const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             const uint8_t* pred_ptr,
+                             ptrdiff_t pred_stride);
 #define vpx_subtract_block vpx_subtract_block_neon
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
 #define vpx_sum_squares_2d_i16 vpx_sum_squares_2d_i16_c
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_16x16_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_tm_predictor_16x16 vpx_tm_predictor_16x16_neon
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_32x32_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_tm_predictor_32x32 vpx_tm_predictor_32x32_neon
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_4x4_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_tm_predictor_4x4 vpx_tm_predictor_4x4_neon
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_8x8_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_tm_predictor_8x8 vpx_tm_predictor_8x8_neon
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_16x16_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_v_predictor_16x16 vpx_v_predictor_16x16_neon
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_32x32_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_v_predictor_32x32 vpx_v_predictor_32x32_neon
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_4x4_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_v_predictor_4x4 vpx_v_predictor_4x4_neon
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_8x8_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_v_predictor_8x8 vpx_v_predictor_8x8_neon
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x16_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance16x16 vpx_variance16x16_neon
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance16x32 vpx_variance16x32_neon
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance16x8_neon(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
 #define vpx_variance16x8 vpx_variance16x8_neon
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x16_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x16 vpx_variance32x16_neon
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x32 vpx_variance32x32_neon
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x64_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x64_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x64 vpx_variance32x64_neon
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x4_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x4_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance4x4 vpx_variance4x4_neon
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x8_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance4x8 vpx_variance4x8_neon
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance64x32 vpx_variance64x32_neon
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x64_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance64x64 vpx_variance64x64_neon
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance8x16_neon(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
 #define vpx_variance8x16 vpx_variance8x16_neon
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x4_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x4_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance8x4 vpx_variance8x4_neon
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x8_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance8x8 vpx_variance8x8_neon
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
-int vpx_vector_var_neon(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
+int vpx_vector_var_neon(const int16_t* ref, const int16_t* src, const int bwl);
 #define vpx_vector_var vpx_vector_var_neon
 
 void vpx_dsp_rtcd(void);
@@ -859,12 +2416,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/ios/arm-neon/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/ios/arm-neon/vpx_scale_rtcd.h b/third_party/libvpx/source/config/ios/arm-neon/vpx_scale_rtcd.h
index 515ce27..564cb3b 100644
--- a/third_party/libvpx/source/config/ios/arm-neon/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/ios/arm-neon/vpx_scale_rtcd.h
@@ -13,43 +13,71 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
@@ -58,12 +86,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/ios/arm64/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/ios/arm64/vp8_rtcd.h b/third_party/libvpx/source/config/ios/arm64/vp8_rtcd.h
index 6a7f92c..c6222d0 100644
--- a/third_party/libvpx/source/config/ios/arm64/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/ios/arm64/vp8_rtcd.h
@@ -26,174 +26,455 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+void vp8_bilinear_predict16x16_neon(unsigned char* src,
+                                    int src_pitch,
+                                    int xofst,
+                                    int yofst,
+                                    unsigned char* dst,
+                                    int dst_pitch);
 #define vp8_bilinear_predict16x16 vp8_bilinear_predict16x16_neon
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict4x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict4x4_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_bilinear_predict4x4 vp8_bilinear_predict4x4_neon
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x4_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_bilinear_predict8x4 vp8_bilinear_predict8x4_neon
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x8_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_bilinear_predict8x8 vp8_bilinear_predict8x8_neon
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
 #define vp8_block_error vp8_block_error_c
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem16x16_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+void vp8_copy_mem16x16_neon(unsigned char* src,
+                            int src_pitch,
+                            unsigned char* dst,
+                            int dst_pitch);
 #define vp8_copy_mem16x16 vp8_copy_mem16x16_neon
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x4_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x4_neon(unsigned char* src,
+                          int src_pitch,
+                          unsigned char* dst,
+                          int dst_pitch);
 #define vp8_copy_mem8x4 vp8_copy_mem8x4_neon
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x8_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x8_neon(unsigned char* src,
+                          int src_pitch,
+                          unsigned char* dst,
+                          int dst_pitch);
 #define vp8_copy_mem8x8 vp8_copy_mem8x8_neon
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-void vp8_dc_only_idct_add_neon(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_dc_only_idct_add_neon(short input,
+                               unsigned char* pred,
+                               int pred_stride,
+                               unsigned char* dst,
+                               int dst_stride);
 #define vp8_dc_only_idct_add vp8_dc_only_idct_add_neon
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_neon(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
+int vp8_denoiser_filter_neon(unsigned char* mc_running_avg_y,
+                             int mc_avg_y_stride,
+                             unsigned char* running_avg_y,
+                             int avg_y_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
 #define vp8_denoiser_filter vp8_denoiser_filter_neon
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_uv_neon(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+int vp8_denoiser_filter_uv_neon(unsigned char* mc_running_avg,
+                                int mc_avg_stride,
+                                unsigned char* running_avg,
+                                int avg_stride,
+                                unsigned char* sig,
+                                int sig_stride,
+                                unsigned int motion_magnitude,
+                                int increase_denoising);
 #define vp8_denoiser_filter_uv vp8_denoiser_filter_uv_neon
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
-void vp8_dequant_idct_add_neon(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
+void vp8_dequant_idct_add_neon(short* input,
+                               short* dq,
+                               unsigned char* output,
+                               int stride);
 #define vp8_dequant_idct_add vp8_dequant_idct_add_neon
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-void vp8_dequant_idct_add_uv_block_neon(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
+void vp8_dequant_idct_add_uv_block_neon(short* q,
+                                        short* dq,
+                                        unsigned char* dst_u,
+                                        unsigned char* dst_v,
+                                        int stride,
+                                        char* eobs);
 #define vp8_dequant_idct_add_uv_block vp8_dequant_idct_add_uv_block_neon
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-void vp8_dequant_idct_add_y_block_neon(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
+void vp8_dequant_idct_add_y_block_neon(short* q,
+                                       short* dq,
+                                       unsigned char* dst,
+                                       int stride,
+                                       char* eobs);
 #define vp8_dequant_idct_add_y_block vp8_dequant_idct_add_y_block_neon
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
-void vp8_dequantize_b_neon(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
+void vp8_dequantize_b_neon(struct blockd*, short* dqc);
 #define vp8_dequantize_b vp8_dequantize_b_neon
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
 #define vp8_diamond_search_sad vp8_diamond_search_sad_c
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
-void vp8_fast_quantize_b_neon(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
+void vp8_fast_quantize_b_neon(struct block*, struct blockd*);
 #define vp8_fast_quantize_b vp8_fast_quantize_b_neon
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp8_filter_by_weight16x16 vp8_filter_by_weight16x16_c
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight8x8 vp8_filter_by_weight8x8_c
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
 #define vp8_full_search_sad vp8_full_search_sad_c
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bh_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bh_neon(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
 #define vp8_loop_filter_bh vp8_loop_filter_bh_neon
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bv_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bv_neon(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
 #define vp8_loop_filter_bv vp8_loop_filter_bv_neon
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbh_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbh_neon(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbh vp8_loop_filter_mbh_neon
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbv_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbv_neon(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbv vp8_loop_filter_mbv_neon
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bhs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bhs_neon(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_bh vp8_loop_filter_bhs_neon
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bvs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bvs_neon(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_bv vp8_loop_filter_bvs_neon
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_mbhs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
+void vp8_loop_filter_mbhs_neon(unsigned char* y,
+                               int ystride,
+                               const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbh vp8_loop_filter_mbhs_neon
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_mbvs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
+void vp8_loop_filter_mbvs_neon(unsigned char* y,
+                               int ystride,
+                               const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbv vp8_loop_filter_mbvs_neon
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
 #define vp8_mbblock_error vp8_mbblock_error_c
 
-int vp8_mbuverror_c(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
 #define vp8_mbuverror vp8_mbuverror_c
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
 #define vp8_refining_search_sad vp8_refining_search_sad_c
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
 #define vp8_regular_quantize_b vp8_regular_quantize_b_c
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct4x4_neon(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct4x4_neon(short* input, short* output, int pitch);
 #define vp8_short_fdct4x4 vp8_short_fdct4x4_neon
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct8x4_neon(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct8x4_neon(short* input, short* output, int pitch);
 #define vp8_short_fdct8x4 vp8_short_fdct8x4_neon
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-void vp8_short_idct4x4llm_neon(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_short_idct4x4llm_neon(short* input,
+                               unsigned char* pred,
+                               int pitch,
+                               unsigned char* dst,
+                               int dst_stride);
 #define vp8_short_idct4x4llm vp8_short_idct4x4llm_neon
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
-void vp8_short_inv_walsh4x4_neon(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
+void vp8_short_inv_walsh4x4_neon(short* input, short* output);
 #define vp8_short_inv_walsh4x4 vp8_short_inv_walsh4x4_neon
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
-void vp8_short_walsh4x4_neon(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
+void vp8_short_walsh4x4_neon(short* input, short* output, int pitch);
 #define vp8_short_walsh4x4 vp8_short_walsh4x4_neon
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict16x16_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_sixtap_predict16x16 vp8_sixtap_predict16x16_neon
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict4x4_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
 #define vp8_sixtap_predict4x4 vp8_sixtap_predict4x4_neon
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x4_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
 #define vp8_sixtap_predict8x4 vp8_sixtap_predict8x4_neon
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x8_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
 #define vp8_sixtap_predict8x8 vp8_sixtap_predict8x8_neon
 
 void vp8_rtcd(void);
@@ -202,12 +483,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/ios/arm64/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/ios/arm64/vp9_rtcd.h b/third_party/libvpx/source/config/ios/arm64/vp9_rtcd.h
index a0f86ea..2ff413b 100644
--- a/third_party/libvpx/source/config/ios/arm64/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/ios/arm64/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,64 +30,192 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
 #define vp9_block_error vp9_block_error_c
 
-int64_t vp9_block_error_fp_c(const int16_t *coeff, const int16_t *dqcoeff, int block_size);
-int64_t vp9_block_error_fp_neon(const int16_t *coeff, const int16_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const int16_t* coeff,
+                             const int16_t* dqcoeff,
+                             int block_size);
+int64_t vp9_block_error_fp_neon(const int16_t* coeff,
+                                const int16_t* dqcoeff,
+                                int block_size);
 #define vp9_block_error_fp vp9_block_error_fp_neon
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-int vp9_denoiser_filter_neon(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
+int vp9_denoiser_filter_neon(const uint8_t* sig,
+                             int sig_stride,
+                             const uint8_t* mc_avg,
+                             int mc_avg_stride,
+                             uint8_t* avg,
+                             int avg_stride,
+                             int increase_denoising,
+                             BLOCK_SIZE bs,
+                             int motion_magnitude);
 #define vp9_denoiser_filter vp9_denoiser_filter_neon
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
 #define vp9_diamond_search_sad vp9_diamond_search_sad_c
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_fdct8x8_quant_neon(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+void vp9_fdct8x8_quant_neon(const int16_t* input,
+                            int stride,
+                            tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vp9_fdct8x8_quant vp9_fdct8x8_quant_neon
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
 #define vp9_fht16x16 vp9_fht16x16_c
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht4x4 vp9_fht4x4_c
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht8x8 vp9_fht8x8_c
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp9_filter_by_weight16x16 vp9_filter_by_weight16x16_c
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp9_filter_by_weight8x8 vp9_filter_by_weight8x8_c
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_fwht4x4 vp9_fwht4x4_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
 #define vp9_iht16x16_256_add vp9_iht16x16_256_add_c
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht4x4_16_add_neon(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht4x4_16_add_neon(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
 #define vp9_iht4x4_16_add vp9_iht4x4_16_add_neon
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht8x8_64_add_neon(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht8x8_64_add_neon(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
 #define vp9_iht8x8_64_add vp9_iht8x8_64_add_neon
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_neon(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
+void vp9_quantize_fp_neon(const tran_low_t* coeff_ptr,
+                          intptr_t n_coeffs,
+                          int skip_block,
+                          const int16_t* round_ptr,
+                          const int16_t* quant_ptr,
+                          tran_low_t* qcoeff_ptr,
+                          tran_low_t* dqcoeff_ptr,
+                          const int16_t* dequant_ptr,
+                          uint16_t* eob_ptr,
+                          const int16_t* scan,
+                          const int16_t* iscan);
 #define vp9_quantize_fp vp9_quantize_fp_neon
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vp9_quantize_fp_32x32 vp9_quantize_fp_32x32_c
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
 #define vp9_scale_and_extend_frame vp9_scale_and_extend_frame_c
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
 #define vp9_temporal_filter_apply vp9_temporal_filter_apply_c
 
 void vp9_rtcd(void);
@@ -96,12 +224,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/ios/arm64/vpx_config.asm

diff --git a/third_party/libvpx/source/config/ios/arm64/vpx_config.asm b/third_party/libvpx/source/config/ios/arm64/vpx_config.asm
index 8400bb4..d52a7412 100644
--- a/third_party/libvpx/source/config/ios/arm64/vpx_config.asm
+++ b/third_party/libvpx/source/config/ios/arm64/vpx_config.asm
@@ -24,6 +24,7 @@
 .set HAVE_AVX ,  0
 .set HAVE_AVX2 ,  0
 .set HAVE_VSX ,  0
+.set HAVE_MMI ,  0
 .set HAVE_VPX_PORTS ,  1
 .set HAVE_PTHREAD_H ,  1
 .set HAVE_UNISTD_H ,  0

third_party/libvpx/source/config/ios/arm64/vpx_config.h

diff --git a/third_party/libvpx/source/config/ios/arm64/vpx_config.h b/third_party/libvpx/source/config/ios/arm64/vpx_config.h
index a3db07d..49da03e 100644
--- a/third_party/libvpx/source/config/ios/arm64/vpx_config.h
+++ b/third_party/libvpx/source/config/ios/arm64/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 0
 #define HAVE_AVX2 0
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/ios/arm64/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/ios/arm64/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/ios/arm64/vpx_dsp_rtcd.h
index c694f53..ae6787f 100644
--- a/third_party/libvpx/source/config/ios/arm64/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/ios/arm64/vpx_dsp_rtcd.h
@@ -14,843 +14,2400 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
-unsigned int vpx_avg_4x4_neon(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
+unsigned int vpx_avg_4x4_neon(const uint8_t*, int p);
 #define vpx_avg_4x4 vpx_avg_4x4_neon
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
-unsigned int vpx_avg_8x8_neon(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
+unsigned int vpx_avg_8x8_neon(const uint8_t*, int p);
 #define vpx_avg_8x8 vpx_avg_8x8_neon
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-void vpx_comp_avg_pred_neon(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
+void vpx_comp_avg_pred_neon(uint8_t* comp_pred,
+                            const uint8_t* pred,
+                            int width,
+                            int height,
+                            const uint8_t* ref,
+                            int ref_stride);
 #define vpx_comp_avg_pred vpx_comp_avg_pred_neon
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_convolve8_neon(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_convolve8 vpx_convolve8_neon
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avg_neon(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_convolve8_avg vpx_convolve8_avg_neon
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_avg_horiz_neon(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 #define vpx_convolve8_avg_horiz vpx_convolve8_avg_horiz_neon
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_avg_vert_neon(const uint8_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h);
 #define vpx_convolve8_avg_vert vpx_convolve8_avg_vert_neon
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+void vpx_convolve8_horiz_neon(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
 #define vpx_convolve8_horiz vpx_convolve8_horiz_neon
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
+void vpx_convolve8_vert_neon(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
 #define vpx_convolve8_vert vpx_convolve8_vert_neon
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_avg_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve_avg_neon(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_convolve_avg vpx_convolve_avg_neon
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_copy_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve_copy_neon(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_convolve_copy vpx_convolve_copy_neon
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d135_predictor_16x16_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_neon
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d135_predictor_32x32_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_neon
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d135_predictor_4x4_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_neon
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d135_predictor_8x8_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_neon
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_16x16 vpx_d153_predictor_16x16_c
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_32x32 vpx_d153_predictor_32x32_c
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_4x4 vpx_d153_predictor_4x4_c
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_8x8 vpx_d153_predictor_8x8_c
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_16x16 vpx_d207_predictor_16x16_c
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_32x32 vpx_d207_predictor_32x32_c
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_4x4 vpx_d207_predictor_4x4_c
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_8x8 vpx_d207_predictor_8x8_c
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_16x16_neon(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_d45_predictor_16x16 vpx_d45_predictor_16x16_neon
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_32x32_neon(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_d45_predictor_32x32 vpx_d45_predictor_32x32_neon
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_4x4_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d45_predictor_4x4 vpx_d45_predictor_4x4_neon
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_8x8_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d45_predictor_8x8 vpx_d45_predictor_8x8_neon
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_16x16 vpx_d63_predictor_16x16_c
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_32x32 vpx_d63_predictor_32x32_c
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_4x4 vpx_d63_predictor_4x4_c
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_8x8 vpx_d63_predictor_8x8_c
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_16x16_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_128_predictor_16x16 vpx_dc_128_predictor_16x16_neon
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_32x32_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_128_predictor_32x32 vpx_dc_128_predictor_32x32_neon
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_4x4_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_128_predictor_4x4 vpx_dc_128_predictor_4x4_neon
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_8x8_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_128_predictor_8x8 vpx_dc_128_predictor_8x8_neon
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_16x16_neon(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
 #define vpx_dc_left_predictor_16x16 vpx_dc_left_predictor_16x16_neon
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_32x32_neon(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
 #define vpx_dc_left_predictor_32x32 vpx_dc_left_predictor_32x32_neon
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_4x4_neon(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
 #define vpx_dc_left_predictor_4x4 vpx_dc_left_predictor_4x4_neon
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_8x8_neon(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
 #define vpx_dc_left_predictor_8x8 vpx_dc_left_predictor_8x8_neon
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_16x16_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_predictor_16x16 vpx_dc_predictor_16x16_neon
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_32x32_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_predictor_32x32 vpx_dc_predictor_32x32_neon
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_4x4_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_dc_predictor_4x4 vpx_dc_predictor_4x4_neon
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_8x8_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_dc_predictor_8x8 vpx_dc_predictor_8x8_neon
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_16x16_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_top_predictor_16x16 vpx_dc_top_predictor_16x16_neon
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_32x32_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_top_predictor_32x32 vpx_dc_top_predictor_32x32_neon
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_4x4_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_top_predictor_4x4 vpx_dc_top_predictor_4x4_neon
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_8x8_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_top_predictor_8x8 vpx_dc_top_predictor_8x8_neon
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16 vpx_fdct16x16_neon
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16_1 vpx_fdct16x16_1_neon
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32 vpx_fdct32x32_neon
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_1 vpx_fdct32x32_1_neon
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_rd_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_rd_neon(const int16_t* input,
+                           tran_low_t* output,
+                           int stride);
 #define vpx_fdct32x32_rd vpx_fdct32x32_rd_neon
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4 vpx_fdct4x4_neon
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4_1 vpx_fdct4x4_1_neon
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8 vpx_fdct8x8_neon
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8_1 vpx_fdct8x8_1_neon
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
+void vpx_get16x16var_neon(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
 #define vpx_get16x16var vpx_get16x16var_neon
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
-unsigned int vpx_get4x4sse_cs_neon(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
+unsigned int vpx_get4x4sse_cs_neon(const unsigned char* src_ptr,
+                                   int source_stride,
+                                   const unsigned char* ref_ptr,
+                                   int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_neon
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get8x8var_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
+void vpx_get8x8var_neon(const uint8_t* src_ptr,
+                        int source_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        unsigned int* sse,
+                        int* sum);
 #define vpx_get8x8var vpx_get8x8var_neon
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
 #define vpx_get_mb_ss vpx_get_mb_ss_c
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_16x16_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_h_predictor_16x16 vpx_h_predictor_16x16_neon
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_32x32_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_h_predictor_32x32 vpx_h_predictor_32x32_neon
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_4x4_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_h_predictor_4x4 vpx_h_predictor_4x4_neon
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_8x8_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_h_predictor_8x8 vpx_h_predictor_8x8_neon
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
-void vpx_hadamard_16x16_neon(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          int16_t* coeff);
+void vpx_hadamard_16x16_neon(const int16_t* src_diff,
+                             int src_stride,
+                             int16_t* coeff);
 #define vpx_hadamard_16x16 vpx_hadamard_16x16_neon
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
-void vpx_hadamard_8x8_neon(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        int16_t* coeff);
+void vpx_hadamard_8x8_neon(const int16_t* src_diff,
+                           int src_stride,
+                           int16_t* coeff);
 #define vpx_hadamard_8x8 vpx_hadamard_8x8_neon
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_10_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_10_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct16x16_10_add vpx_idct16x16_10_add_neon
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_1_add_neon(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct16x16_1_add vpx_idct16x16_1_add_neon
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_256_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct16x16_256_add_neon(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
 #define vpx_idct16x16_256_add vpx_idct16x16_256_add_neon
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_38_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_38_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct16x16_38_add vpx_idct16x16_38_add_neon
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+void vpx_idct32x32_1024_add_neon(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
 #define vpx_idct32x32_1024_add vpx_idct32x32_1024_add_neon
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_135_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct32x32_135_add_neon(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
 #define vpx_idct32x32_135_add vpx_idct32x32_135_add_neon
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_1_add_neon(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct32x32_1_add vpx_idct32x32_1_add_neon
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_34_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct32x32_34_add vpx_idct32x32_34_add_neon
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_16_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_16_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct4x4_16_add vpx_idct4x4_16_add_neon
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_1_add_neon(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_1_add vpx_idct4x4_1_add_neon
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_12_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct8x8_12_add vpx_idct8x8_12_add_neon
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_1_add_neon(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_1_add vpx_idct8x8_1_add_neon
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_64_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_64_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct8x8_64_add vpx_idct8x8_64_add_neon
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
-int16_t vpx_int_pro_col_neon(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
+int16_t vpx_int_pro_col_neon(const uint8_t* ref, const int width);
 #define vpx_int_pro_col vpx_int_pro_col_neon
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-void vpx_int_pro_row_neon(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
+void vpx_int_pro_row_neon(int16_t* hbuf,
+                          const uint8_t* ref,
+                          const int ref_stride,
+                          const int height);
 #define vpx_int_pro_row vpx_int_pro_row_neon
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_16_add vpx_iwht4x4_16_add_c
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+void vpx_lpf_horizontal_16_neon(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
 #define vpx_lpf_horizontal_16 vpx_lpf_horizontal_16_neon
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_neon(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
 #define vpx_lpf_horizontal_16_dual vpx_lpf_horizontal_16_dual_neon
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_4_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_4_neon(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
 #define vpx_lpf_horizontal_4 vpx_lpf_horizontal_4_neon
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_4_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_4_dual_neon(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
 #define vpx_lpf_horizontal_4_dual vpx_lpf_horizontal_4_dual_neon
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_8_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_8_neon(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
 #define vpx_lpf_horizontal_8 vpx_lpf_horizontal_8_neon
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_8_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_8_dual_neon(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
 #define vpx_lpf_horizontal_8_dual vpx_lpf_horizontal_8_dual_neon
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
+void vpx_lpf_vertical_16_neon(uint8_t* s,
+                              int pitch,
+                              const uint8_t* blimit,
+                              const uint8_t* limit,
+                              const uint8_t* thresh);
 #define vpx_lpf_vertical_16 vpx_lpf_vertical_16_neon
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_vertical_16_dual_neon(uint8_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh);
 #define vpx_lpf_vertical_16_dual vpx_lpf_vertical_16_dual_neon
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_4_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_4_neon(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_vertical_4 vpx_lpf_vertical_4_neon
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_4_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_4_dual_neon(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
 #define vpx_lpf_vertical_4_dual vpx_lpf_vertical_4_dual_neon
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_8_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_8_neon(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_vertical_8 vpx_lpf_vertical_8_neon
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_8_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_8_dual_neon(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
 #define vpx_lpf_vertical_8_dual vpx_lpf_vertical_8_dual_neon
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_across_ip_neon(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
+void vpx_mbpost_proc_across_ip_neon(unsigned char* dst,
+                                    int pitch,
+                                    int rows,
+                                    int cols,
+                                    int flimit);
 #define vpx_mbpost_proc_across_ip vpx_mbpost_proc_across_ip_neon
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_down_neon(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
+void vpx_mbpost_proc_down_neon(unsigned char* dst,
+                               int pitch,
+                               int rows,
+                               int cols,
+                               int flimit);
 #define vpx_mbpost_proc_down vpx_mbpost_proc_down_neon
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-void vpx_minmax_8x8_neon(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
+void vpx_minmax_8x8_neon(const uint8_t* s,
+                         int p,
+                         const uint8_t* d,
+                         int dp,
+                         int* min,
+                         int* max);
 #define vpx_minmax_8x8 vpx_minmax_8x8_neon
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_neon(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
+unsigned int vpx_mse16x16_neon(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
 #define vpx_mse16x16 vpx_mse16x16_neon
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse16x8 vpx_mse16x8_c
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse8x16 vpx_mse8x16_c
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
 #define vpx_mse8x8 vpx_mse8x8_c
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
 #define vpx_plane_add_noise vpx_plane_add_noise_c
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-void vpx_post_proc_down_and_across_mb_row_neon(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-#define vpx_post_proc_down_and_across_mb_row vpx_post_proc_down_and_across_mb_row_neon
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+void vpx_post_proc_down_and_across_mb_row_neon(unsigned char* src,
+                                               unsigned char* dst,
+                                               int src_pitch,
+                                               int dst_pitch,
+                                               int cols,
+                                               unsigned char* flimits,
+                                               int size);
+#define vpx_post_proc_down_and_across_mb_row \
+  vpx_post_proc_down_and_across_mb_row_neon
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-#define vpx_quantize_b vpx_quantize_b_c
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
+void vpx_quantize_b_neon(const tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* zbin_ptr,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         const int16_t* quant_shift_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+#define vpx_quantize_b vpx_quantize_b_neon
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vpx_quantize_b_32x32 vpx_quantize_b_32x32_c
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x16_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad16x16 vpx_sad16x16_neon
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x16_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad16x16_avg vpx_sad16x16_avg_neon
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x3 vpx_sad16x16x3_c
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x16x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad16x16x4d vpx_sad16x16x4d_neon
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x8 vpx_sad16x16x8_c
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad16x32 vpx_sad16x32_neon
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad16x32_avg vpx_sad16x32_avg_neon
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad16x32x4d vpx_sad16x32x4d_neon
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad16x8_neon(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
 #define vpx_sad16x8 vpx_sad16x8_neon
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad16x8_avg_neon(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
 #define vpx_sad16x8_avg vpx_sad16x8_avg_neon
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x3 vpx_sad16x8x3_c
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x8x4d_neon(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
 #define vpx_sad16x8x4d vpx_sad16x8x4d_neon
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x8 vpx_sad16x8x8_c
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x16_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad32x16 vpx_sad32x16_neon
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad32x16_avg vpx_sad32x16_avg_neon
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x16x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x16x4d vpx_sad32x16x4d_neon
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad32x32 vpx_sad32x32_neon
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad32x32_avg vpx_sad32x32_avg_neon
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x32x4d vpx_sad32x32x4d_neon
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x64_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad32x64 vpx_sad32x64_neon
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad32x64_avg vpx_sad32x64_avg_neon
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x64x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x64x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x64x4d vpx_sad32x64x4d_neon
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x4_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x4_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad4x4 vpx_sad4x4_neon
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x4_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x4_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad4x4_avg vpx_sad4x4_avg_neon
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x3 vpx_sad4x4x3_c
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x4x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad4x4x4d vpx_sad4x4x4d_neon
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x8 vpx_sad4x4x8_c
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x8_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad4x8 vpx_sad4x8_neon
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x8_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad4x8_avg vpx_sad4x8_avg_neon
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x8x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad4x8x4d vpx_sad4x8x4d_neon
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad64x32 vpx_sad64x32_neon
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad64x32_avg vpx_sad64x32_avg_neon
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad64x32x4d vpx_sad64x32x4d_neon
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x64_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad64x64 vpx_sad64x64_neon
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad64x64_avg vpx_sad64x64_avg_neon
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x64x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad64x64x4d vpx_sad64x64x4d_neon
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad8x16_neon(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
 #define vpx_sad8x16 vpx_sad8x16_neon
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad8x16_avg_neon(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
 #define vpx_sad8x16_avg vpx_sad8x16_avg_neon
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x3 vpx_sad8x16x3_c
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad8x16x4d_neon(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
 #define vpx_sad8x16x4d vpx_sad8x16x4d_neon
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x8 vpx_sad8x16x8_c
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x4_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x4_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad8x4 vpx_sad8x4_neon
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x4_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x4_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad8x4_avg vpx_sad8x4_avg_neon
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x4x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x4x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad8x4x4d vpx_sad8x4x4d_neon
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x8_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad8x8 vpx_sad8x8_neon
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x8_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad8x8_avg vpx_sad8x8_avg_neon
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x3 vpx_sad8x8x3_c
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x8x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad8x8x4d vpx_sad8x8x4d_neon
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x8 vpx_sad8x8x8_c
 
-int vpx_satd_c(const int16_t *coeff, int length);
-int vpx_satd_neon(const int16_t *coeff, int length);
+int vpx_satd_c(const int16_t* coeff, int length);
+int vpx_satd_neon(const int16_t* coeff, int length);
 #define vpx_satd vpx_satd_neon
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_scaled_2d vpx_scaled_2d_c
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x16 vpx_sub_pixel_avg_variance16x16_neon
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x32 vpx_sub_pixel_avg_variance16x32_neon
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_neon(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x8 vpx_sub_pixel_avg_variance16x8_neon
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x16 vpx_sub_pixel_avg_variance32x16_neon
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x32 vpx_sub_pixel_avg_variance32x32_neon
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x64 vpx_sub_pixel_avg_variance32x64_neon
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x4 vpx_sub_pixel_avg_variance4x4_neon
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x8 vpx_sub_pixel_avg_variance4x8_neon
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x32 vpx_sub_pixel_avg_variance64x32_neon
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x64 vpx_sub_pixel_avg_variance64x64_neon
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_neon(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x16 vpx_sub_pixel_avg_variance8x16_neon
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x4 vpx_sub_pixel_avg_variance8x4_neon
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x8 vpx_sub_pixel_avg_variance8x8_neon
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance16x16 vpx_sub_pixel_variance16x16_neon
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance16x32 vpx_sub_pixel_variance16x32_neon
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_neon(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
 #define vpx_sub_pixel_variance16x8 vpx_sub_pixel_variance16x8_neon
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance32x16 vpx_sub_pixel_variance32x16_neon
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance32x32 vpx_sub_pixel_variance32x32_neon
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance32x64 vpx_sub_pixel_variance32x64_neon
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance4x4 vpx_sub_pixel_variance4x4_neon
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance4x8 vpx_sub_pixel_variance4x8_neon
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance64x32 vpx_sub_pixel_variance64x32_neon
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance64x64 vpx_sub_pixel_variance64x64_neon
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_neon(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
 #define vpx_sub_pixel_variance8x16 vpx_sub_pixel_variance8x16_neon
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance8x4 vpx_sub_pixel_variance8x4_neon
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance8x8 vpx_sub_pixel_variance8x8_neon
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-void vpx_subtract_block_neon(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
+void vpx_subtract_block_neon(int rows,
+                             int cols,
+                             int16_t* diff_ptr,
+                             ptrdiff_t diff_stride,
+                             const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             const uint8_t* pred_ptr,
+                             ptrdiff_t pred_stride);
 #define vpx_subtract_block vpx_subtract_block_neon
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
 #define vpx_sum_squares_2d_i16 vpx_sum_squares_2d_i16_c
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_16x16_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_tm_predictor_16x16 vpx_tm_predictor_16x16_neon
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_32x32_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_tm_predictor_32x32 vpx_tm_predictor_32x32_neon
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_4x4_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_tm_predictor_4x4 vpx_tm_predictor_4x4_neon
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_8x8_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_tm_predictor_8x8 vpx_tm_predictor_8x8_neon
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_16x16_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_v_predictor_16x16 vpx_v_predictor_16x16_neon
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_32x32_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_v_predictor_32x32 vpx_v_predictor_32x32_neon
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_4x4_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_v_predictor_4x4 vpx_v_predictor_4x4_neon
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_8x8_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_v_predictor_8x8 vpx_v_predictor_8x8_neon
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x16_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance16x16 vpx_variance16x16_neon
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance16x32 vpx_variance16x32_neon
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance16x8_neon(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
 #define vpx_variance16x8 vpx_variance16x8_neon
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x16_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x16 vpx_variance32x16_neon
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x32 vpx_variance32x32_neon
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x64_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x64_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x64 vpx_variance32x64_neon
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x4_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x4_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance4x4 vpx_variance4x4_neon
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x8_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance4x8 vpx_variance4x8_neon
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance64x32 vpx_variance64x32_neon
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x64_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance64x64 vpx_variance64x64_neon
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance8x16_neon(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
 #define vpx_variance8x16 vpx_variance8x16_neon
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x4_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x4_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance8x4 vpx_variance8x4_neon
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x8_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance8x8 vpx_variance8x8_neon
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
-int vpx_vector_var_neon(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
+int vpx_vector_var_neon(const int16_t* ref, const int16_t* src, const int bwl);
 #define vpx_vector_var vpx_vector_var_neon
 
 void vpx_dsp_rtcd(void);
@@ -859,12 +2416,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/ios/arm64/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/ios/arm64/vpx_scale_rtcd.h b/third_party/libvpx/source/config/ios/arm64/vpx_scale_rtcd.h
index 515ce27..564cb3b 100644
--- a/third_party/libvpx/source/config/ios/arm64/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/ios/arm64/vpx_scale_rtcd.h
@@ -13,43 +13,71 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
@@ -58,12 +86,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vp8_rtcd.h b/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vp8_rtcd.h
index 9acdcc0..f89a505 100644
--- a/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vp8_rtcd.h
@@ -26,175 +26,567 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict16x16)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+void vp8_bilinear_predict16x16_neon(unsigned char* src,
+                                    int src_pitch,
+                                    int xofst,
+                                    int yofst,
+                                    unsigned char* dst,
+                                    int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict16x16)(unsigned char* src,
+                                              int src_pitch,
+                                              int xofst,
+                                              int yofst,
+                                              unsigned char* dst,
+                                              int dst_pitch);
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict4x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict4x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict4x4_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict4x4)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict8x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x4_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict8x4)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict8x8)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x8_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict8x8)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
 #define vp8_block_error vp8_block_error_c
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem16x16_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_copy_mem16x16)(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+void vp8_copy_mem16x16_neon(unsigned char* src,
+                            int src_pitch,
+                            unsigned char* dst,
+                            int dst_pitch);
+RTCD_EXTERN void (*vp8_copy_mem16x16)(unsigned char* src,
+                                      int src_pitch,
+                                      unsigned char* dst,
+                                      int dst_pitch);
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x4_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_copy_mem8x4)(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x4_neon(unsigned char* src,
+                          int src_pitch,
+                          unsigned char* dst,
+                          int dst_pitch);
+RTCD_EXTERN void (*vp8_copy_mem8x4)(unsigned char* src,
+                                    int src_pitch,
+                                    unsigned char* dst,
+                                    int dst_pitch);
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x8_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_copy_mem8x8)(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x8_neon(unsigned char* src,
+                          int src_pitch,
+                          unsigned char* dst,
+                          int dst_pitch);
+RTCD_EXTERN void (*vp8_copy_mem8x8)(unsigned char* src,
+                                    int src_pitch,
+                                    unsigned char* dst,
+                                    int dst_pitch);
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-void vp8_dc_only_idct_add_neon(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-RTCD_EXTERN void (*vp8_dc_only_idct_add)(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_dc_only_idct_add_neon(short input,
+                               unsigned char* pred,
+                               int pred_stride,
+                               unsigned char* dst,
+                               int dst_stride);
+RTCD_EXTERN void (*vp8_dc_only_idct_add)(short input,
+                                         unsigned char* pred,
+                                         int pred_stride,
+                                         unsigned char* dst,
+                                         int dst_stride);
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_neon(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-RTCD_EXTERN int (*vp8_denoiser_filter)(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
+int vp8_denoiser_filter_neon(unsigned char* mc_running_avg_y,
+                             int mc_avg_y_stride,
+                             unsigned char* running_avg_y,
+                             int avg_y_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+RTCD_EXTERN int (*vp8_denoiser_filter)(unsigned char* mc_running_avg_y,
+                                       int mc_avg_y_stride,
+                                       unsigned char* running_avg_y,
+                                       int avg_y_stride,
+                                       unsigned char* sig,
+                                       int sig_stride,
+                                       unsigned int motion_magnitude,
+                                       int increase_denoising);
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_uv_neon(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-RTCD_EXTERN int (*vp8_denoiser_filter_uv)(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+int vp8_denoiser_filter_uv_neon(unsigned char* mc_running_avg,
+                                int mc_avg_stride,
+                                unsigned char* running_avg,
+                                int avg_stride,
+                                unsigned char* sig,
+                                int sig_stride,
+                                unsigned int motion_magnitude,
+                                int increase_denoising);
+RTCD_EXTERN int (*vp8_denoiser_filter_uv)(unsigned char* mc_running_avg,
+                                          int mc_avg_stride,
+                                          unsigned char* running_avg,
+                                          int avg_stride,
+                                          unsigned char* sig,
+                                          int sig_stride,
+                                          unsigned int motion_magnitude,
+                                          int increase_denoising);
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
-void vp8_dequant_idct_add_neon(short *input, short *dq, unsigned char *output, int stride);
-RTCD_EXTERN void (*vp8_dequant_idct_add)(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
+void vp8_dequant_idct_add_neon(short* input,
+                               short* dq,
+                               unsigned char* output,
+                               int stride);
+RTCD_EXTERN void (*vp8_dequant_idct_add)(short* input,
+                                         short* dq,
+                                         unsigned char* output,
+                                         int stride);
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-void vp8_dequant_idct_add_uv_block_neon(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-RTCD_EXTERN void (*vp8_dequant_idct_add_uv_block)(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
+void vp8_dequant_idct_add_uv_block_neon(short* q,
+                                        short* dq,
+                                        unsigned char* dst_u,
+                                        unsigned char* dst_v,
+                                        int stride,
+                                        char* eobs);
+RTCD_EXTERN void (*vp8_dequant_idct_add_uv_block)(short* q,
+                                                  short* dq,
+                                                  unsigned char* dst_u,
+                                                  unsigned char* dst_v,
+                                                  int stride,
+                                                  char* eobs);
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-void vp8_dequant_idct_add_y_block_neon(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-RTCD_EXTERN void (*vp8_dequant_idct_add_y_block)(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
+void vp8_dequant_idct_add_y_block_neon(short* q,
+                                       short* dq,
+                                       unsigned char* dst,
+                                       int stride,
+                                       char* eobs);
+RTCD_EXTERN void (*vp8_dequant_idct_add_y_block)(short* q,
+                                                 short* dq,
+                                                 unsigned char* dst,
+                                                 int stride,
+                                                 char* eobs);
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
-void vp8_dequantize_b_neon(struct blockd*, short *dqc);
-RTCD_EXTERN void (*vp8_dequantize_b)(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
+void vp8_dequantize_b_neon(struct blockd*, short* dqc);
+RTCD_EXTERN void (*vp8_dequantize_b)(struct blockd*, short* dqc);
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
 #define vp8_diamond_search_sad vp8_diamond_search_sad_c
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
-void vp8_fast_quantize_b_neon(struct block *, struct blockd *);
-RTCD_EXTERN void (*vp8_fast_quantize_b)(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
+void vp8_fast_quantize_b_neon(struct block*, struct blockd*);
+RTCD_EXTERN void (*vp8_fast_quantize_b)(struct block*, struct blockd*);
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp8_filter_by_weight16x16 vp8_filter_by_weight16x16_c
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight8x8 vp8_filter_by_weight8x8_c
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
 #define vp8_full_search_sad vp8_full_search_sad_c
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bh_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_bh)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bh_neon(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_bh)(unsigned char* y,
+                                       unsigned char* u,
+                                       unsigned char* v,
+                                       int ystride,
+                                       int uv_stride,
+                                       struct loop_filter_info* lfi);
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bv_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_bv)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bv_neon(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_bv)(unsigned char* y,
+                                       unsigned char* u,
+                                       unsigned char* v,
+                                       int ystride,
+                                       int uv_stride,
+                                       struct loop_filter_info* lfi);
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbh_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_mbh)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbh_neon(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_mbh)(unsigned char* y,
+                                        unsigned char* u,
+                                        unsigned char* v,
+                                        int ystride,
+                                        int uv_stride,
+                                        struct loop_filter_info* lfi);
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbv_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_mbv)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbv_neon(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_mbv)(unsigned char* y,
+                                        unsigned char* u,
+                                        unsigned char* v,
+                                        int ystride,
+                                        int uv_stride,
+                                        struct loop_filter_info* lfi);
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bhs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_bh)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bhs_neon(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_bh)(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bvs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_bv)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bvs_neon(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_bv)(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_mbhs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_mbh)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
+void vp8_loop_filter_mbhs_neon(unsigned char* y,
+                               int ystride,
+                               const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_mbh)(unsigned char* y,
+                                               int ystride,
+                                               const unsigned char* blimit);
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_mbvs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_mbv)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
+void vp8_loop_filter_mbvs_neon(unsigned char* y,
+                               int ystride,
+                               const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_mbv)(unsigned char* y,
+                                               int ystride,
+                                               const unsigned char* blimit);
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
 #define vp8_mbblock_error vp8_mbblock_error_c
 
-int vp8_mbuverror_c(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
 #define vp8_mbuverror vp8_mbuverror_c
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
 #define vp8_refining_search_sad vp8_refining_search_sad_c
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
 #define vp8_regular_quantize_b vp8_regular_quantize_b_c
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct4x4_neon(short *input, short *output, int pitch);
-RTCD_EXTERN void (*vp8_short_fdct4x4)(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct4x4_neon(short* input, short* output, int pitch);
+RTCD_EXTERN void (*vp8_short_fdct4x4)(short* input, short* output, int pitch);
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct8x4_neon(short *input, short *output, int pitch);
-RTCD_EXTERN void (*vp8_short_fdct8x4)(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct8x4_neon(short* input, short* output, int pitch);
+RTCD_EXTERN void (*vp8_short_fdct8x4)(short* input, short* output, int pitch);
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-void vp8_short_idct4x4llm_neon(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-RTCD_EXTERN void (*vp8_short_idct4x4llm)(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_short_idct4x4llm_neon(short* input,
+                               unsigned char* pred,
+                               int pitch,
+                               unsigned char* dst,
+                               int dst_stride);
+RTCD_EXTERN void (*vp8_short_idct4x4llm)(short* input,
+                                         unsigned char* pred,
+                                         int pitch,
+                                         unsigned char* dst,
+                                         int dst_stride);
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
-void vp8_short_inv_walsh4x4_neon(short *input, short *output);
-RTCD_EXTERN void (*vp8_short_inv_walsh4x4)(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
+void vp8_short_inv_walsh4x4_neon(short* input, short* output);
+RTCD_EXTERN void (*vp8_short_inv_walsh4x4)(short* input, short* output);
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
-void vp8_short_walsh4x4_neon(short *input, short *output, int pitch);
-RTCD_EXTERN void (*vp8_short_walsh4x4)(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
+void vp8_short_walsh4x4_neon(short* input, short* output, int pitch);
+RTCD_EXTERN void (*vp8_short_walsh4x4)(short* input, short* output, int pitch);
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict16x16)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict16x16_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict16x16)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict4x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict4x4_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict4x4)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict8x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x4_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict8x4)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict8x8)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x8_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict8x8)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
 void vp8_rtcd(void);
 
@@ -202,76 +594,107 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_c;
-    if (flags & HAS_NEON) vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_neon;
-    vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_c;
-    if (flags & HAS_NEON) vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_neon;
-    vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_c;
-    if (flags & HAS_NEON) vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_neon;
-    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_c;
-    if (flags & HAS_NEON) vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_neon;
-    vp8_copy_mem16x16 = vp8_copy_mem16x16_c;
-    if (flags & HAS_NEON) vp8_copy_mem16x16 = vp8_copy_mem16x16_neon;
-    vp8_copy_mem8x4 = vp8_copy_mem8x4_c;
-    if (flags & HAS_NEON) vp8_copy_mem8x4 = vp8_copy_mem8x4_neon;
-    vp8_copy_mem8x8 = vp8_copy_mem8x8_c;
-    if (flags & HAS_NEON) vp8_copy_mem8x8 = vp8_copy_mem8x8_neon;
-    vp8_dc_only_idct_add = vp8_dc_only_idct_add_c;
-    if (flags & HAS_NEON) vp8_dc_only_idct_add = vp8_dc_only_idct_add_neon;
-    vp8_denoiser_filter = vp8_denoiser_filter_c;
-    if (flags & HAS_NEON) vp8_denoiser_filter = vp8_denoiser_filter_neon;
-    vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_c;
-    if (flags & HAS_NEON) vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_neon;
-    vp8_dequant_idct_add = vp8_dequant_idct_add_c;
-    if (flags & HAS_NEON) vp8_dequant_idct_add = vp8_dequant_idct_add_neon;
-    vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_c;
-    if (flags & HAS_NEON) vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_neon;
-    vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_c;
-    if (flags & HAS_NEON) vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_neon;
-    vp8_dequantize_b = vp8_dequantize_b_c;
-    if (flags & HAS_NEON) vp8_dequantize_b = vp8_dequantize_b_neon;
-    vp8_fast_quantize_b = vp8_fast_quantize_b_c;
-    if (flags & HAS_NEON) vp8_fast_quantize_b = vp8_fast_quantize_b_neon;
-    vp8_loop_filter_bh = vp8_loop_filter_bh_c;
-    if (flags & HAS_NEON) vp8_loop_filter_bh = vp8_loop_filter_bh_neon;
-    vp8_loop_filter_bv = vp8_loop_filter_bv_c;
-    if (flags & HAS_NEON) vp8_loop_filter_bv = vp8_loop_filter_bv_neon;
-    vp8_loop_filter_mbh = vp8_loop_filter_mbh_c;
-    if (flags & HAS_NEON) vp8_loop_filter_mbh = vp8_loop_filter_mbh_neon;
-    vp8_loop_filter_mbv = vp8_loop_filter_mbv_c;
-    if (flags & HAS_NEON) vp8_loop_filter_mbv = vp8_loop_filter_mbv_neon;
-    vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_c;
-    if (flags & HAS_NEON) vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_neon;
-    vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_c;
-    if (flags & HAS_NEON) vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_neon;
-    vp8_loop_filter_simple_mbh = vp8_loop_filter_simple_horizontal_edge_c;
-    if (flags & HAS_NEON) vp8_loop_filter_simple_mbh = vp8_loop_filter_mbhs_neon;
-    vp8_loop_filter_simple_mbv = vp8_loop_filter_simple_vertical_edge_c;
-    if (flags & HAS_NEON) vp8_loop_filter_simple_mbv = vp8_loop_filter_mbvs_neon;
-    vp8_short_fdct4x4 = vp8_short_fdct4x4_c;
-    if (flags & HAS_NEON) vp8_short_fdct4x4 = vp8_short_fdct4x4_neon;
-    vp8_short_fdct8x4 = vp8_short_fdct8x4_c;
-    if (flags & HAS_NEON) vp8_short_fdct8x4 = vp8_short_fdct8x4_neon;
-    vp8_short_idct4x4llm = vp8_short_idct4x4llm_c;
-    if (flags & HAS_NEON) vp8_short_idct4x4llm = vp8_short_idct4x4llm_neon;
-    vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_c;
-    if (flags & HAS_NEON) vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_neon;
-    vp8_short_walsh4x4 = vp8_short_walsh4x4_c;
-    if (flags & HAS_NEON) vp8_short_walsh4x4 = vp8_short_walsh4x4_neon;
-    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_c;
-    if (flags & HAS_NEON) vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_neon;
-    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_c;
-    if (flags & HAS_NEON) vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_neon;
-    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_c;
-    if (flags & HAS_NEON) vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_neon;
-    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_c;
-    if (flags & HAS_NEON) vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_neon;
+  vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_c;
+  if (flags & HAS_NEON)
+    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_neon;
+  vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_c;
+  if (flags & HAS_NEON)
+    vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_neon;
+  vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_c;
+  if (flags & HAS_NEON)
+    vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_neon;
+  vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_c;
+  if (flags & HAS_NEON)
+    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_neon;
+  vp8_copy_mem16x16 = vp8_copy_mem16x16_c;
+  if (flags & HAS_NEON)
+    vp8_copy_mem16x16 = vp8_copy_mem16x16_neon;
+  vp8_copy_mem8x4 = vp8_copy_mem8x4_c;
+  if (flags & HAS_NEON)
+    vp8_copy_mem8x4 = vp8_copy_mem8x4_neon;
+  vp8_copy_mem8x8 = vp8_copy_mem8x8_c;
+  if (flags & HAS_NEON)
+    vp8_copy_mem8x8 = vp8_copy_mem8x8_neon;
+  vp8_dc_only_idct_add = vp8_dc_only_idct_add_c;
+  if (flags & HAS_NEON)
+    vp8_dc_only_idct_add = vp8_dc_only_idct_add_neon;
+  vp8_denoiser_filter = vp8_denoiser_filter_c;
+  if (flags & HAS_NEON)
+    vp8_denoiser_filter = vp8_denoiser_filter_neon;
+  vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_c;
+  if (flags & HAS_NEON)
+    vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_neon;
+  vp8_dequant_idct_add = vp8_dequant_idct_add_c;
+  if (flags & HAS_NEON)
+    vp8_dequant_idct_add = vp8_dequant_idct_add_neon;
+  vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_c;
+  if (flags & HAS_NEON)
+    vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_neon;
+  vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_c;
+  if (flags & HAS_NEON)
+    vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_neon;
+  vp8_dequantize_b = vp8_dequantize_b_c;
+  if (flags & HAS_NEON)
+    vp8_dequantize_b = vp8_dequantize_b_neon;
+  vp8_fast_quantize_b = vp8_fast_quantize_b_c;
+  if (flags & HAS_NEON)
+    vp8_fast_quantize_b = vp8_fast_quantize_b_neon;
+  vp8_loop_filter_bh = vp8_loop_filter_bh_c;
+  if (flags & HAS_NEON)
+    vp8_loop_filter_bh = vp8_loop_filter_bh_neon;
+  vp8_loop_filter_bv = vp8_loop_filter_bv_c;
+  if (flags & HAS_NEON)
+    vp8_loop_filter_bv = vp8_loop_filter_bv_neon;
+  vp8_loop_filter_mbh = vp8_loop_filter_mbh_c;
+  if (flags & HAS_NEON)
+    vp8_loop_filter_mbh = vp8_loop_filter_mbh_neon;
+  vp8_loop_filter_mbv = vp8_loop_filter_mbv_c;
+  if (flags & HAS_NEON)
+    vp8_loop_filter_mbv = vp8_loop_filter_mbv_neon;
+  vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_c;
+  if (flags & HAS_NEON)
+    vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_neon;
+  vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_c;
+  if (flags & HAS_NEON)
+    vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_neon;
+  vp8_loop_filter_simple_mbh = vp8_loop_filter_simple_horizontal_edge_c;
+  if (flags & HAS_NEON)
+    vp8_loop_filter_simple_mbh = vp8_loop_filter_mbhs_neon;
+  vp8_loop_filter_simple_mbv = vp8_loop_filter_simple_vertical_edge_c;
+  if (flags & HAS_NEON)
+    vp8_loop_filter_simple_mbv = vp8_loop_filter_mbvs_neon;
+  vp8_short_fdct4x4 = vp8_short_fdct4x4_c;
+  if (flags & HAS_NEON)
+    vp8_short_fdct4x4 = vp8_short_fdct4x4_neon;
+  vp8_short_fdct8x4 = vp8_short_fdct8x4_c;
+  if (flags & HAS_NEON)
+    vp8_short_fdct8x4 = vp8_short_fdct8x4_neon;
+  vp8_short_idct4x4llm = vp8_short_idct4x4llm_c;
+  if (flags & HAS_NEON)
+    vp8_short_idct4x4llm = vp8_short_idct4x4llm_neon;
+  vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_c;
+  if (flags & HAS_NEON)
+    vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_neon;
+  vp8_short_walsh4x4 = vp8_short_walsh4x4_c;
+  if (flags & HAS_NEON)
+    vp8_short_walsh4x4 = vp8_short_walsh4x4_neon;
+  vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_c;
+  if (flags & HAS_NEON)
+    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_neon;
+  vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_c;
+  if (flags & HAS_NEON)
+    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_neon;
+  vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_c;
+  if (flags & HAS_NEON)
+    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_neon;
+  vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_c;
+  if (flags & HAS_NEON)
+    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_neon;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vp9_rtcd.h b/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vp9_rtcd.h
index 8de66ff9..c763dcc 100644
--- a/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,64 +30,230 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
 #define vp9_block_error vp9_block_error_c
 
-int64_t vp9_block_error_fp_c(const int16_t *coeff, const int16_t *dqcoeff, int block_size);
-int64_t vp9_block_error_fp_neon(const int16_t *coeff, const int16_t *dqcoeff, int block_size);
-RTCD_EXTERN int64_t (*vp9_block_error_fp)(const int16_t *coeff, const int16_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const int16_t* coeff,
+                             const int16_t* dqcoeff,
+                             int block_size);
+int64_t vp9_block_error_fp_neon(const int16_t* coeff,
+                                const int16_t* dqcoeff,
+                                int block_size);
+RTCD_EXTERN int64_t (*vp9_block_error_fp)(const int16_t* coeff,
+                                          const int16_t* dqcoeff,
+                                          int block_size);
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-int vp9_denoiser_filter_neon(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-RTCD_EXTERN int (*vp9_denoiser_filter)(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
+int vp9_denoiser_filter_neon(const uint8_t* sig,
+                             int sig_stride,
+                             const uint8_t* mc_avg,
+                             int mc_avg_stride,
+                             uint8_t* avg,
+                             int avg_stride,
+                             int increase_denoising,
+                             BLOCK_SIZE bs,
+                             int motion_magnitude);
+RTCD_EXTERN int (*vp9_denoiser_filter)(const uint8_t* sig,
+                                       int sig_stride,
+                                       const uint8_t* mc_avg,
+                                       int mc_avg_stride,
+                                       uint8_t* avg,
+                                       int avg_stride,
+                                       int increase_denoising,
+                                       BLOCK_SIZE bs,
+                                       int motion_magnitude);
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
 #define vp9_diamond_search_sad vp9_diamond_search_sad_c
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_fdct8x8_quant_neon(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_fdct8x8_quant)(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+void vp9_fdct8x8_quant_neon(const int16_t* input,
+                            int stride,
+                            tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
+RTCD_EXTERN void (*vp9_fdct8x8_quant)(const int16_t* input,
+                                      int stride,
+                                      tran_low_t* coeff_ptr,
+                                      intptr_t n_coeffs,
+                                      int skip_block,
+                                      const int16_t* round_ptr,
+                                      const int16_t* quant_ptr,
+                                      tran_low_t* qcoeff_ptr,
+                                      tran_low_t* dqcoeff_ptr,
+                                      const int16_t* dequant_ptr,
+                                      uint16_t* eob_ptr,
+                                      const int16_t* scan,
+                                      const int16_t* iscan);
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
 #define vp9_fht16x16 vp9_fht16x16_c
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht4x4 vp9_fht4x4_c
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht8x8 vp9_fht8x8_c
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp9_filter_by_weight16x16 vp9_filter_by_weight16x16_c
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp9_filter_by_weight8x8 vp9_filter_by_weight8x8_c
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_fwht4x4 vp9_fwht4x4_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
 #define vp9_iht16x16_256_add vp9_iht16x16_256_add_c
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht4x4_16_add_neon(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_iht4x4_16_add)(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht4x4_16_add_neon(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
+RTCD_EXTERN void (*vp9_iht4x4_16_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride,
+                                      int tx_type);
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht8x8_64_add_neon(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_iht8x8_64_add)(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht8x8_64_add_neon(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
+RTCD_EXTERN void (*vp9_iht8x8_64_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride,
+                                      int tx_type);
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_neon(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_quantize_fp)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
+void vp9_quantize_fp_neon(const tran_low_t* coeff_ptr,
+                          intptr_t n_coeffs,
+                          int skip_block,
+                          const int16_t* round_ptr,
+                          const int16_t* quant_ptr,
+                          tran_low_t* qcoeff_ptr,
+                          tran_low_t* dqcoeff_ptr,
+                          const int16_t* dequant_ptr,
+                          uint16_t* eob_ptr,
+                          const int16_t* scan,
+                          const int16_t* iscan);
+RTCD_EXTERN void (*vp9_quantize_fp)(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vp9_quantize_fp_32x32 vp9_quantize_fp_32x32_c
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
 #define vp9_scale_and_extend_frame vp9_scale_and_extend_frame_c
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
 #define vp9_temporal_filter_apply vp9_temporal_filter_apply_c
 
 void vp9_rtcd(void);
@@ -96,24 +262,29 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vp9_block_error_fp = vp9_block_error_fp_c;
-    if (flags & HAS_NEON) vp9_block_error_fp = vp9_block_error_fp_neon;
-    vp9_denoiser_filter = vp9_denoiser_filter_c;
-    if (flags & HAS_NEON) vp9_denoiser_filter = vp9_denoiser_filter_neon;
-    vp9_fdct8x8_quant = vp9_fdct8x8_quant_c;
-    if (flags & HAS_NEON) vp9_fdct8x8_quant = vp9_fdct8x8_quant_neon;
-    vp9_iht4x4_16_add = vp9_iht4x4_16_add_c;
-    if (flags & HAS_NEON) vp9_iht4x4_16_add = vp9_iht4x4_16_add_neon;
-    vp9_iht8x8_64_add = vp9_iht8x8_64_add_c;
-    if (flags & HAS_NEON) vp9_iht8x8_64_add = vp9_iht8x8_64_add_neon;
-    vp9_quantize_fp = vp9_quantize_fp_c;
-    if (flags & HAS_NEON) vp9_quantize_fp = vp9_quantize_fp_neon;
+  vp9_block_error_fp = vp9_block_error_fp_c;
+  if (flags & HAS_NEON)
+    vp9_block_error_fp = vp9_block_error_fp_neon;
+  vp9_denoiser_filter = vp9_denoiser_filter_c;
+  if (flags & HAS_NEON)
+    vp9_denoiser_filter = vp9_denoiser_filter_neon;
+  vp9_fdct8x8_quant = vp9_fdct8x8_quant_c;
+  if (flags & HAS_NEON)
+    vp9_fdct8x8_quant = vp9_fdct8x8_quant_neon;
+  vp9_iht4x4_16_add = vp9_iht4x4_16_add_c;
+  if (flags & HAS_NEON)
+    vp9_iht4x4_16_add = vp9_iht4x4_16_add_neon;
+  vp9_iht8x8_64_add = vp9_iht8x8_64_add_c;
+  if (flags & HAS_NEON)
+    vp9_iht8x8_64_add = vp9_iht8x8_64_add_neon;
+  vp9_quantize_fp = vp9_quantize_fp_c;
+  if (flags & HAS_NEON)
+    vp9_quantize_fp = vp9_quantize_fp_neon;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_config.asm

diff --git a/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_config.asm b/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_config.asm
index a07e4df..cef9e61 100644
--- a/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_config.asm
+++ b/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_config.asm
@@ -21,6 +21,7 @@
 .equ HAVE_AVX ,  0
 .equ HAVE_AVX2 ,  0
 .equ HAVE_VSX ,  0
+.equ HAVE_MMI ,  0
 .equ HAVE_VPX_PORTS ,  1
 .equ HAVE_PTHREAD_H ,  1
 .equ HAVE_UNISTD_H ,  0

third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_config.h

diff --git a/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_config.h b/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_config.h
index c7576b6..4b972bf 100644
--- a/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_config.h
+++ b/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 0
 #define HAVE_AVX2 0
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_dsp_rtcd.h
index a607a57..7f74ccf 100644
--- a/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_dsp_rtcd.h
@@ -14,844 +14,3130 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
-unsigned int vpx_avg_4x4_neon(const uint8_t *, int p);
-RTCD_EXTERN unsigned int (*vpx_avg_4x4)(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
+unsigned int vpx_avg_4x4_neon(const uint8_t*, int p);
+RTCD_EXTERN unsigned int (*vpx_avg_4x4)(const uint8_t*, int p);
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
-unsigned int vpx_avg_8x8_neon(const uint8_t *, int p);
-RTCD_EXTERN unsigned int (*vpx_avg_8x8)(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
+unsigned int vpx_avg_8x8_neon(const uint8_t*, int p);
+RTCD_EXTERN unsigned int (*vpx_avg_8x8)(const uint8_t*, int p);
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-void vpx_comp_avg_pred_neon(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-RTCD_EXTERN void (*vpx_comp_avg_pred)(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
+void vpx_comp_avg_pred_neon(uint8_t* comp_pred,
+                            const uint8_t* pred,
+                            int width,
+                            int height,
+                            const uint8_t* ref,
+                            int ref_stride);
+RTCD_EXTERN void (*vpx_comp_avg_pred)(uint8_t* comp_pred,
+                                      const uint8_t* pred,
+                                      int width,
+                                      int height,
+                                      const uint8_t* ref,
+                                      int ref_stride);
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_convolve8_neon(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+RTCD_EXTERN void (*vpx_convolve8)(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avg_neon(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
+RTCD_EXTERN void (*vpx_convolve8_avg)(const uint8_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h);
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg_horiz)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_avg_horiz_neon(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
+RTCD_EXTERN void (*vpx_convolve8_avg_horiz)(const uint8_t* src,
+                                            ptrdiff_t src_stride,
+                                            uint8_t* dst,
+                                            ptrdiff_t dst_stride,
+                                            const int16_t* filter_x,
+                                            int x_step_q4,
+                                            const int16_t* filter_y,
+                                            int y_step_q4,
+                                            int w,
+                                            int h);
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg_vert)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_avg_vert_neon(const uint8_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h);
+RTCD_EXTERN void (*vpx_convolve8_avg_vert)(const uint8_t* src,
+                                           ptrdiff_t src_stride,
+                                           uint8_t* dst,
+                                           ptrdiff_t dst_stride,
+                                           const int16_t* filter_x,
+                                           int x_step_q4,
+                                           const int16_t* filter_y,
+                                           int y_step_q4,
+                                           int w,
+                                           int h);
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_horiz)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+void vpx_convolve8_horiz_neon(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+RTCD_EXTERN void (*vpx_convolve8_horiz)(const uint8_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint8_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h);
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_vert)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
+void vpx_convolve8_vert_neon(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+RTCD_EXTERN void (*vpx_convolve8_vert)(const uint8_t* src,
+                                       ptrdiff_t src_stride,
+                                       uint8_t* dst,
+                                       ptrdiff_t dst_stride,
+                                       const int16_t* filter_x,
+                                       int x_step_q4,
+                                       const int16_t* filter_y,
+                                       int y_step_q4,
+                                       int w,
+                                       int h);
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_avg_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve_avg)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve_avg_neon(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+RTCD_EXTERN void (*vpx_convolve_avg)(const uint8_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint8_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h);
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_copy_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve_copy)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve_copy_neon(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
+RTCD_EXTERN void (*vpx_convolve_copy)(const uint8_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h);
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d135_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d135_predictor_16x16_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d135_predictor_16x16)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d135_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d135_predictor_32x32_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d135_predictor_32x32)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d135_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d135_predictor_4x4_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d135_predictor_4x4)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d135_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d135_predictor_8x8_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d135_predictor_8x8)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_16x16 vpx_d153_predictor_16x16_c
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_32x32 vpx_d153_predictor_32x32_c
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_4x4 vpx_d153_predictor_4x4_c
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_8x8 vpx_d153_predictor_8x8_c
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_16x16 vpx_d207_predictor_16x16_c
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_32x32 vpx_d207_predictor_32x32_c
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_4x4 vpx_d207_predictor_4x4_c
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_8x8 vpx_d207_predictor_8x8_c
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_16x16_neon(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_16x16)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_32x32_neon(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_32x32)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_4x4_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_4x4)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_8x8_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_8x8)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_16x16 vpx_d63_predictor_16x16_c
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_32x32 vpx_d63_predictor_32x32_c
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_4x4 vpx_d63_predictor_4x4_c
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_8x8 vpx_d63_predictor_8x8_c
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_16x16_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_16x16)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_32x32_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_32x32)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_4x4_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_4x4)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_8x8_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_8x8)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_16x16_neon(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_16x16)(uint8_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint8_t* above,
+                                                const uint8_t* left);
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_32x32_neon(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_32x32)(uint8_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint8_t* above,
+                                                const uint8_t* left);
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_4x4_neon(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_4x4)(uint8_t* dst,
+                                              ptrdiff_t y_stride,
+                                              const uint8_t* above,
+                                              const uint8_t* left);
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_8x8_neon(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_8x8)(uint8_t* dst,
+                                              ptrdiff_t y_stride,
+                                              const uint8_t* above,
+                                              const uint8_t* left);
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_16x16_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_16x16)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_32x32_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_32x32)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_4x4_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_4x4)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_8x8_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_8x8)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_16x16_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_16x16)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_32x32_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_32x32)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_4x4_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_4x4)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_8x8_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_8x8)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_neon(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct16x16)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_neon(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct16x16)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_1_neon(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct16x16_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_1_neon(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct16x16_1)(const int16_t* input,
+                                    tran_low_t* output,
+                                    int stride);
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_neon(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct32x32)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_neon(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct32x32)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_1_neon(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct32x32_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_1_neon(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct32x32_1)(const int16_t* input,
+                                    tran_low_t* output,
+                                    int stride);
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_rd_neon(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct32x32_rd)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_rd_neon(const int16_t* input,
+                           tran_low_t* output,
+                           int stride);
+RTCD_EXTERN void (*vpx_fdct32x32_rd)(const int16_t* input,
+                                     tran_low_t* output,
+                                     int stride);
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_neon(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct4x4)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_neon(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct4x4)(const int16_t* input,
+                                tran_low_t* output,
+                                int stride);
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_1_neon(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct4x4_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_1_neon(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct4x4_1)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_neon(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct8x8)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_neon(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct8x8)(const int16_t* input,
+                                tran_low_t* output,
+                                int stride);
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_1_neon(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct8x8_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_1_neon(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct8x8_1)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-RTCD_EXTERN void (*vpx_get16x16var)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
+void vpx_get16x16var_neon(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
+RTCD_EXTERN void (*vpx_get16x16var)(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse,
+                                    int* sum);
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
-unsigned int vpx_get4x4sse_cs_neon(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
-RTCD_EXTERN unsigned int (*vpx_get4x4sse_cs)(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
+unsigned int vpx_get4x4sse_cs_neon(const unsigned char* src_ptr,
+                                   int source_stride,
+                                   const unsigned char* ref_ptr,
+                                   int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_get4x4sse_cs)(const unsigned char* src_ptr,
+                                             int source_stride,
+                                             const unsigned char* ref_ptr,
+                                             int ref_stride);
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get8x8var_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-RTCD_EXTERN void (*vpx_get8x8var)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
+void vpx_get8x8var_neon(const uint8_t* src_ptr,
+                        int source_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        unsigned int* sse,
+                        int* sum);
+RTCD_EXTERN void (*vpx_get8x8var)(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse,
+                                  int* sum);
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
 #define vpx_get_mb_ss vpx_get_mb_ss_c
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_16x16_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_16x16)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_32x32_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_32x32)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_4x4_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_4x4)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_8x8_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_8x8)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
-void vpx_hadamard_16x16_neon(const int16_t *src_diff, int src_stride, int16_t *coeff);
-RTCD_EXTERN void (*vpx_hadamard_16x16)(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          int16_t* coeff);
+void vpx_hadamard_16x16_neon(const int16_t* src_diff,
+                             int src_stride,
+                             int16_t* coeff);
+RTCD_EXTERN void (*vpx_hadamard_16x16)(const int16_t* src_diff,
+                                       int src_stride,
+                                       int16_t* coeff);
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
-void vpx_hadamard_8x8_neon(const int16_t *src_diff, int src_stride, int16_t *coeff);
-RTCD_EXTERN void (*vpx_hadamard_8x8)(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        int16_t* coeff);
+void vpx_hadamard_8x8_neon(const int16_t* src_diff,
+                           int src_stride,
+                           int16_t* coeff);
+RTCD_EXTERN void (*vpx_hadamard_8x8)(const int16_t* src_diff,
+                                     int src_stride,
+                                     int16_t* coeff);
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_10_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_10_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_10_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+RTCD_EXTERN void (*vpx_idct16x16_10_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_1_add_neon(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+RTCD_EXTERN void (*vpx_idct16x16_1_add)(const tran_low_t* input,
+                                        uint8_t* dest,
+                                        int stride);
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_256_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_256_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct16x16_256_add_neon(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
+RTCD_EXTERN void (*vpx_idct16x16_256_add)(const tran_low_t* input,
+                                          uint8_t* dest,
+                                          int stride);
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_38_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_38_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_38_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+RTCD_EXTERN void (*vpx_idct16x16_38_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_1024_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+void vpx_idct32x32_1024_add_neon(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+RTCD_EXTERN void (*vpx_idct32x32_1024_add)(const tran_low_t* input,
+                                           uint8_t* dest,
+                                           int stride);
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_135_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_135_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct32x32_135_add_neon(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
+RTCD_EXTERN void (*vpx_idct32x32_135_add)(const tran_low_t* input,
+                                          uint8_t* dest,
+                                          int stride);
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_1_add_neon(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+RTCD_EXTERN void (*vpx_idct32x32_1_add)(const tran_low_t* input,
+                                        uint8_t* dest,
+                                        int stride);
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_34_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_34_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+RTCD_EXTERN void (*vpx_idct32x32_34_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_16_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct4x4_16_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_16_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+RTCD_EXTERN void (*vpx_idct4x4_16_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct4x4_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_1_add_neon(const tran_low_t* input, uint8_t* dest, int stride);
+RTCD_EXTERN void (*vpx_idct4x4_1_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride);
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_12_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_12_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+RTCD_EXTERN void (*vpx_idct8x8_12_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_1_add_neon(const tran_low_t* input, uint8_t* dest, int stride);
+RTCD_EXTERN void (*vpx_idct8x8_1_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride);
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_64_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_64_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_64_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+RTCD_EXTERN void (*vpx_idct8x8_64_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
-int16_t vpx_int_pro_col_neon(const uint8_t *ref, const int width);
-RTCD_EXTERN int16_t (*vpx_int_pro_col)(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
+int16_t vpx_int_pro_col_neon(const uint8_t* ref, const int width);
+RTCD_EXTERN int16_t (*vpx_int_pro_col)(const uint8_t* ref, const int width);
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-void vpx_int_pro_row_neon(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-RTCD_EXTERN void (*vpx_int_pro_row)(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
+void vpx_int_pro_row_neon(int16_t* hbuf,
+                          const uint8_t* ref,
+                          const int ref_stride,
+                          const int height);
+RTCD_EXTERN void (*vpx_int_pro_row)(int16_t* hbuf,
+                                    const uint8_t* ref,
+                                    const int ref_stride,
+                                    const int height);
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_16_add vpx_iwht4x4_16_add_c
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_16)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+void vpx_lpf_horizontal_16_neon(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_16)(uint8_t* s,
+                                          int pitch,
+                                          const uint8_t* blimit,
+                                          const uint8_t* limit,
+                                          const uint8_t* thresh);
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_16_dual)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_neon(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_16_dual)(uint8_t* s,
+                                               int pitch,
+                                               const uint8_t* blimit,
+                                               const uint8_t* limit,
+                                               const uint8_t* thresh);
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_4_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_4)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_4_neon(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_4)(uint8_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh);
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_4_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_horizontal_4_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_4_dual_neon(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_horizontal_4_dual)(uint8_t* s,
+                                              int pitch,
+                                              const uint8_t* blimit0,
+                                              const uint8_t* limit0,
+                                              const uint8_t* thresh0,
+                                              const uint8_t* blimit1,
+                                              const uint8_t* limit1,
+                                              const uint8_t* thresh1);
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_8_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_8)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_8_neon(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_8)(uint8_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh);
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_8_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_horizontal_8_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_8_dual_neon(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_horizontal_8_dual)(uint8_t* s,
+                                              int pitch,
+                                              const uint8_t* blimit0,
+                                              const uint8_t* limit0,
+                                              const uint8_t* thresh0,
+                                              const uint8_t* blimit1,
+                                              const uint8_t* limit1,
+                                              const uint8_t* thresh1);
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_16)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
+void vpx_lpf_vertical_16_neon(uint8_t* s,
+                              int pitch,
+                              const uint8_t* blimit,
+                              const uint8_t* limit,
+                              const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_16)(uint8_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit,
+                                        const uint8_t* limit,
+                                        const uint8_t* thresh);
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_16_dual)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_vertical_16_dual_neon(uint8_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_16_dual)(uint8_t* s,
+                                             int pitch,
+                                             const uint8_t* blimit,
+                                             const uint8_t* limit,
+                                             const uint8_t* thresh);
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_4_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_4)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_4_neon(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_4)(uint8_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh);
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_4_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_vertical_4_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_4_dual_neon(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_vertical_4_dual)(uint8_t* s,
+                                            int pitch,
+                                            const uint8_t* blimit0,
+                                            const uint8_t* limit0,
+                                            const uint8_t* thresh0,
+                                            const uint8_t* blimit1,
+                                            const uint8_t* limit1,
+                                            const uint8_t* thresh1);
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_8_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_8)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_8_neon(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_8)(uint8_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh);
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_8_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_vertical_8_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_8_dual_neon(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_vertical_8_dual)(uint8_t* s,
+                                            int pitch,
+                                            const uint8_t* blimit0,
+                                            const uint8_t* limit0,
+                                            const uint8_t* thresh0,
+                                            const uint8_t* blimit1,
+                                            const uint8_t* limit1,
+                                            const uint8_t* thresh1);
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_across_ip_neon(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-RTCD_EXTERN void (*vpx_mbpost_proc_across_ip)(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
+void vpx_mbpost_proc_across_ip_neon(unsigned char* dst,
+                                    int pitch,
+                                    int rows,
+                                    int cols,
+                                    int flimit);
+RTCD_EXTERN void (*vpx_mbpost_proc_across_ip)(unsigned char* dst,
+                                              int pitch,
+                                              int rows,
+                                              int cols,
+                                              int flimit);
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_down_neon(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-RTCD_EXTERN void (*vpx_mbpost_proc_down)(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
+void vpx_mbpost_proc_down_neon(unsigned char* dst,
+                               int pitch,
+                               int rows,
+                               int cols,
+                               int flimit);
+RTCD_EXTERN void (*vpx_mbpost_proc_down)(unsigned char* dst,
+                                         int pitch,
+                                         int rows,
+                                         int cols,
+                                         int flimit);
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-void vpx_minmax_8x8_neon(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-RTCD_EXTERN void (*vpx_minmax_8x8)(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
+void vpx_minmax_8x8_neon(const uint8_t* s,
+                         int p,
+                         const uint8_t* d,
+                         int dp,
+                         int* min,
+                         int* max);
+RTCD_EXTERN void (*vpx_minmax_8x8)(const uint8_t* s,
+                                   int p,
+                                   const uint8_t* d,
+                                   int dp,
+                                   int* min,
+                                   int* max);
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_neon(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
+unsigned int vpx_mse16x16_neon(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse16x16)(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse16x8 vpx_mse16x8_c
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse8x16 vpx_mse8x16_c
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
 #define vpx_mse8x8 vpx_mse8x8_c
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
 #define vpx_plane_add_noise vpx_plane_add_noise_c
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-void vpx_post_proc_down_and_across_mb_row_neon(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-RTCD_EXTERN void (*vpx_post_proc_down_and_across_mb_row)(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+void vpx_post_proc_down_and_across_mb_row_neon(unsigned char* src,
+                                               unsigned char* dst,
+                                               int src_pitch,
+                                               int dst_pitch,
+                                               int cols,
+                                               unsigned char* flimits,
+                                               int size);
+RTCD_EXTERN void (*vpx_post_proc_down_and_across_mb_row)(unsigned char* src,
+                                                         unsigned char* dst,
+                                                         int src_pitch,
+                                                         int dst_pitch,
+                                                         int cols,
+                                                         unsigned char* flimits,
+                                                         int size);
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-#define vpx_quantize_b vpx_quantize_b_c
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
+void vpx_quantize_b_neon(const tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* zbin_ptr,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         const int16_t* quant_shift_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+RTCD_EXTERN void (*vpx_quantize_b)(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vpx_quantize_b_32x32 vpx_quantize_b_32x32_c
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad16x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x16_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad16x16)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad16x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x16_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad16x16_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x3 vpx_sad16x16x3_c
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x16x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x8 vpx_sad16x16x8_c
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad16x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad16x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad16x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad16x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad16x8_neon(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad16x8)(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad16x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad16x8_avg_neon(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad16x8_avg)(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            const uint8_t* second_pred);
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x3 vpx_sad16x8x3_c
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x8x4d_neon(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x4d)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x8 vpx_sad16x8x8_c
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x16_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x16)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x16_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x16x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x16x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x64_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x64)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x64_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x64x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x64x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x64x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x4_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad4x4)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x4_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad4x4)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x4_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad4x4_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x4_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad4x4_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x3 vpx_sad4x4x3_c
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x4x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x8 vpx_sad4x4x8_c
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad4x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x8_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad4x8)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad4x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x8_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad4x8_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x8x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x8x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad64x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad64x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad64x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad64x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad64x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad64x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad64x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x64_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad64x64)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad64x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad64x64_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad64x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x64x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad64x64x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad8x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad8x16_neon(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad8x16)(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad8x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad8x16_avg_neon(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad8x16_avg)(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            const uint8_t* second_pred);
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x3 vpx_sad8x16x3_c
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad8x16x4d_neon(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x4d)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x8 vpx_sad8x16x8_c
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x4_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad8x4)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x4_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad8x4)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x4_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad8x4_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x4_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad8x4_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x4x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x4x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x4x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x4x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x8_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad8x8)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad8x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x8_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad8x8_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x3 vpx_sad8x8x3_c
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x8x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x8 vpx_sad8x8x8_c
 
-int vpx_satd_c(const int16_t *coeff, int length);
-int vpx_satd_neon(const int16_t *coeff, int length);
-RTCD_EXTERN int (*vpx_satd)(const int16_t *coeff, int length);
+int vpx_satd_c(const int16_t* coeff, int length);
+int vpx_satd_neon(const int16_t* coeff, int length);
+RTCD_EXTERN int (*vpx_satd)(const int16_t* coeff, int length);
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_scaled_2d vpx_scaled_2d_c
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_neon(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_neon(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x16)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_neon(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x8)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x16)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x64)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x4)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x8)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x64)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_neon(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x16)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x4)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x8)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-void vpx_subtract_block_neon(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-RTCD_EXTERN void (*vpx_subtract_block)(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
+void vpx_subtract_block_neon(int rows,
+                             int cols,
+                             int16_t* diff_ptr,
+                             ptrdiff_t diff_stride,
+                             const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             const uint8_t* pred_ptr,
+                             ptrdiff_t pred_stride);
+RTCD_EXTERN void (*vpx_subtract_block)(int rows,
+                                       int cols,
+                                       int16_t* diff_ptr,
+                                       ptrdiff_t diff_stride,
+                                       const uint8_t* src_ptr,
+                                       ptrdiff_t src_stride,
+                                       const uint8_t* pred_ptr,
+                                       ptrdiff_t pred_stride);
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
 #define vpx_sum_squares_2d_i16 vpx_sum_squares_2d_i16_c
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_16x16_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_16x16)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_32x32_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_32x32)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_4x4_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_4x4)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_8x8_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_8x8)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_16x16_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_16x16)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_32x32_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_32x32)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_4x4_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_4x4)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_8x8_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_8x8)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x16_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x16)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance16x8_neon(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x8)(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x16_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x16)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x64_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x64_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x64)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x4_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance4x4)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x4_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance4x4)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance4x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x8_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance4x8)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance64x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x64_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance64x64)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance8x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance8x16_neon(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance8x16)(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x4_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance8x4)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x4_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance8x4)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance8x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x8_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance8x8)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
-int vpx_vector_var_neon(const int16_t *ref, const int16_t *src, const int bwl);
-RTCD_EXTERN int (*vpx_vector_var)(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
+int vpx_vector_var_neon(const int16_t* ref, const int16_t* src, const int bwl);
+RTCD_EXTERN int (*vpx_vector_var)(const int16_t* ref,
+                                  const int16_t* src,
+                                  const int bwl);
 
 void vpx_dsp_rtcd(void);
 
@@ -859,360 +3145,537 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vpx_avg_4x4 = vpx_avg_4x4_c;
-    if (flags & HAS_NEON) vpx_avg_4x4 = vpx_avg_4x4_neon;
-    vpx_avg_8x8 = vpx_avg_8x8_c;
-    if (flags & HAS_NEON) vpx_avg_8x8 = vpx_avg_8x8_neon;
-    vpx_comp_avg_pred = vpx_comp_avg_pred_c;
-    if (flags & HAS_NEON) vpx_comp_avg_pred = vpx_comp_avg_pred_neon;
-    vpx_convolve8 = vpx_convolve8_c;
-    if (flags & HAS_NEON) vpx_convolve8 = vpx_convolve8_neon;
-    vpx_convolve8_avg = vpx_convolve8_avg_c;
-    if (flags & HAS_NEON) vpx_convolve8_avg = vpx_convolve8_avg_neon;
-    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_c;
-    if (flags & HAS_NEON) vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_neon;
-    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_c;
-    if (flags & HAS_NEON) vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_neon;
-    vpx_convolve8_horiz = vpx_convolve8_horiz_c;
-    if (flags & HAS_NEON) vpx_convolve8_horiz = vpx_convolve8_horiz_neon;
-    vpx_convolve8_vert = vpx_convolve8_vert_c;
-    if (flags & HAS_NEON) vpx_convolve8_vert = vpx_convolve8_vert_neon;
-    vpx_convolve_avg = vpx_convolve_avg_c;
-    if (flags & HAS_NEON) vpx_convolve_avg = vpx_convolve_avg_neon;
-    vpx_convolve_copy = vpx_convolve_copy_c;
-    if (flags & HAS_NEON) vpx_convolve_copy = vpx_convolve_copy_neon;
-    vpx_d135_predictor_16x16 = vpx_d135_predictor_16x16_c;
-    if (flags & HAS_NEON) vpx_d135_predictor_16x16 = vpx_d135_predictor_16x16_neon;
-    vpx_d135_predictor_32x32 = vpx_d135_predictor_32x32_c;
-    if (flags & HAS_NEON) vpx_d135_predictor_32x32 = vpx_d135_predictor_32x32_neon;
-    vpx_d135_predictor_4x4 = vpx_d135_predictor_4x4_c;
-    if (flags & HAS_NEON) vpx_d135_predictor_4x4 = vpx_d135_predictor_4x4_neon;
-    vpx_d135_predictor_8x8 = vpx_d135_predictor_8x8_c;
-    if (flags & HAS_NEON) vpx_d135_predictor_8x8 = vpx_d135_predictor_8x8_neon;
-    vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_c;
-    if (flags & HAS_NEON) vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_neon;
-    vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_c;
-    if (flags & HAS_NEON) vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_neon;
-    vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_c;
-    if (flags & HAS_NEON) vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_neon;
-    vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_c;
-    if (flags & HAS_NEON) vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_neon;
-    vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_c;
-    if (flags & HAS_NEON) vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_neon;
-    vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_c;
-    if (flags & HAS_NEON) vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_neon;
-    vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_c;
-    if (flags & HAS_NEON) vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_neon;
-    vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_c;
-    if (flags & HAS_NEON) vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_neon;
-    vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_c;
-    if (flags & HAS_NEON) vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_neon;
-    vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_c;
-    if (flags & HAS_NEON) vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_neon;
-    vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_c;
-    if (flags & HAS_NEON) vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_neon;
-    vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_c;
-    if (flags & HAS_NEON) vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_neon;
-    vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_c;
-    if (flags & HAS_NEON) vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_neon;
-    vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_c;
-    if (flags & HAS_NEON) vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_neon;
-    vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_c;
-    if (flags & HAS_NEON) vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_neon;
-    vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_c;
-    if (flags & HAS_NEON) vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_neon;
-    vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_c;
-    if (flags & HAS_NEON) vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_neon;
-    vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_c;
-    if (flags & HAS_NEON) vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_neon;
-    vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_c;
-    if (flags & HAS_NEON) vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_neon;
-    vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_c;
-    if (flags & HAS_NEON) vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_neon;
-    vpx_fdct16x16 = vpx_fdct16x16_c;
-    if (flags & HAS_NEON) vpx_fdct16x16 = vpx_fdct16x16_neon;
-    vpx_fdct16x16_1 = vpx_fdct16x16_1_c;
-    if (flags & HAS_NEON) vpx_fdct16x16_1 = vpx_fdct16x16_1_neon;
-    vpx_fdct32x32 = vpx_fdct32x32_c;
-    if (flags & HAS_NEON) vpx_fdct32x32 = vpx_fdct32x32_neon;
-    vpx_fdct32x32_1 = vpx_fdct32x32_1_c;
-    if (flags & HAS_NEON) vpx_fdct32x32_1 = vpx_fdct32x32_1_neon;
-    vpx_fdct32x32_rd = vpx_fdct32x32_rd_c;
-    if (flags & HAS_NEON) vpx_fdct32x32_rd = vpx_fdct32x32_rd_neon;
-    vpx_fdct4x4 = vpx_fdct4x4_c;
-    if (flags & HAS_NEON) vpx_fdct4x4 = vpx_fdct4x4_neon;
-    vpx_fdct4x4_1 = vpx_fdct4x4_1_c;
-    if (flags & HAS_NEON) vpx_fdct4x4_1 = vpx_fdct4x4_1_neon;
-    vpx_fdct8x8 = vpx_fdct8x8_c;
-    if (flags & HAS_NEON) vpx_fdct8x8 = vpx_fdct8x8_neon;
-    vpx_fdct8x8_1 = vpx_fdct8x8_1_c;
-    if (flags & HAS_NEON) vpx_fdct8x8_1 = vpx_fdct8x8_1_neon;
-    vpx_get16x16var = vpx_get16x16var_c;
-    if (flags & HAS_NEON) vpx_get16x16var = vpx_get16x16var_neon;
-    vpx_get4x4sse_cs = vpx_get4x4sse_cs_c;
-    if (flags & HAS_NEON) vpx_get4x4sse_cs = vpx_get4x4sse_cs_neon;
-    vpx_get8x8var = vpx_get8x8var_c;
-    if (flags & HAS_NEON) vpx_get8x8var = vpx_get8x8var_neon;
-    vpx_h_predictor_16x16 = vpx_h_predictor_16x16_c;
-    if (flags & HAS_NEON) vpx_h_predictor_16x16 = vpx_h_predictor_16x16_neon;
-    vpx_h_predictor_32x32 = vpx_h_predictor_32x32_c;
-    if (flags & HAS_NEON) vpx_h_predictor_32x32 = vpx_h_predictor_32x32_neon;
-    vpx_h_predictor_4x4 = vpx_h_predictor_4x4_c;
-    if (flags & HAS_NEON) vpx_h_predictor_4x4 = vpx_h_predictor_4x4_neon;
-    vpx_h_predictor_8x8 = vpx_h_predictor_8x8_c;
-    if (flags & HAS_NEON) vpx_h_predictor_8x8 = vpx_h_predictor_8x8_neon;
-    vpx_hadamard_16x16 = vpx_hadamard_16x16_c;
-    if (flags & HAS_NEON) vpx_hadamard_16x16 = vpx_hadamard_16x16_neon;
-    vpx_hadamard_8x8 = vpx_hadamard_8x8_c;
-    if (flags & HAS_NEON) vpx_hadamard_8x8 = vpx_hadamard_8x8_neon;
-    vpx_idct16x16_10_add = vpx_idct16x16_10_add_c;
-    if (flags & HAS_NEON) vpx_idct16x16_10_add = vpx_idct16x16_10_add_neon;
-    vpx_idct16x16_1_add = vpx_idct16x16_1_add_c;
-    if (flags & HAS_NEON) vpx_idct16x16_1_add = vpx_idct16x16_1_add_neon;
-    vpx_idct16x16_256_add = vpx_idct16x16_256_add_c;
-    if (flags & HAS_NEON) vpx_idct16x16_256_add = vpx_idct16x16_256_add_neon;
-    vpx_idct16x16_38_add = vpx_idct16x16_38_add_c;
-    if (flags & HAS_NEON) vpx_idct16x16_38_add = vpx_idct16x16_38_add_neon;
-    vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_c;
-    if (flags & HAS_NEON) vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_neon;
-    vpx_idct32x32_135_add = vpx_idct32x32_135_add_c;
-    if (flags & HAS_NEON) vpx_idct32x32_135_add = vpx_idct32x32_135_add_neon;
-    vpx_idct32x32_1_add = vpx_idct32x32_1_add_c;
-    if (flags & HAS_NEON) vpx_idct32x32_1_add = vpx_idct32x32_1_add_neon;
-    vpx_idct32x32_34_add = vpx_idct32x32_34_add_c;
-    if (flags & HAS_NEON) vpx_idct32x32_34_add = vpx_idct32x32_34_add_neon;
-    vpx_idct4x4_16_add = vpx_idct4x4_16_add_c;
-    if (flags & HAS_NEON) vpx_idct4x4_16_add = vpx_idct4x4_16_add_neon;
-    vpx_idct4x4_1_add = vpx_idct4x4_1_add_c;
-    if (flags & HAS_NEON) vpx_idct4x4_1_add = vpx_idct4x4_1_add_neon;
-    vpx_idct8x8_12_add = vpx_idct8x8_12_add_c;
-    if (flags & HAS_NEON) vpx_idct8x8_12_add = vpx_idct8x8_12_add_neon;
-    vpx_idct8x8_1_add = vpx_idct8x8_1_add_c;
-    if (flags & HAS_NEON) vpx_idct8x8_1_add = vpx_idct8x8_1_add_neon;
-    vpx_idct8x8_64_add = vpx_idct8x8_64_add_c;
-    if (flags & HAS_NEON) vpx_idct8x8_64_add = vpx_idct8x8_64_add_neon;
-    vpx_int_pro_col = vpx_int_pro_col_c;
-    if (flags & HAS_NEON) vpx_int_pro_col = vpx_int_pro_col_neon;
-    vpx_int_pro_row = vpx_int_pro_row_c;
-    if (flags & HAS_NEON) vpx_int_pro_row = vpx_int_pro_row_neon;
-    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_c;
-    if (flags & HAS_NEON) vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_neon;
-    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_c;
-    if (flags & HAS_NEON) vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_neon;
-    vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_c;
-    if (flags & HAS_NEON) vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_neon;
-    vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_c;
-    if (flags & HAS_NEON) vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_neon;
-    vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_c;
-    if (flags & HAS_NEON) vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_neon;
-    vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_c;
-    if (flags & HAS_NEON) vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_neon;
-    vpx_lpf_vertical_16 = vpx_lpf_vertical_16_c;
-    if (flags & HAS_NEON) vpx_lpf_vertical_16 = vpx_lpf_vertical_16_neon;
-    vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_c;
-    if (flags & HAS_NEON) vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_neon;
-    vpx_lpf_vertical_4 = vpx_lpf_vertical_4_c;
-    if (flags & HAS_NEON) vpx_lpf_vertical_4 = vpx_lpf_vertical_4_neon;
-    vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_c;
-    if (flags & HAS_NEON) vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_neon;
-    vpx_lpf_vertical_8 = vpx_lpf_vertical_8_c;
-    if (flags & HAS_NEON) vpx_lpf_vertical_8 = vpx_lpf_vertical_8_neon;
-    vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_c;
-    if (flags & HAS_NEON) vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_neon;
-    vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_c;
-    if (flags & HAS_NEON) vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_neon;
-    vpx_mbpost_proc_down = vpx_mbpost_proc_down_c;
-    if (flags & HAS_NEON) vpx_mbpost_proc_down = vpx_mbpost_proc_down_neon;
-    vpx_minmax_8x8 = vpx_minmax_8x8_c;
-    if (flags & HAS_NEON) vpx_minmax_8x8 = vpx_minmax_8x8_neon;
-    vpx_mse16x16 = vpx_mse16x16_c;
-    if (flags & HAS_NEON) vpx_mse16x16 = vpx_mse16x16_neon;
-    vpx_post_proc_down_and_across_mb_row = vpx_post_proc_down_and_across_mb_row_c;
-    if (flags & HAS_NEON) vpx_post_proc_down_and_across_mb_row = vpx_post_proc_down_and_across_mb_row_neon;
-    vpx_sad16x16 = vpx_sad16x16_c;
-    if (flags & HAS_NEON) vpx_sad16x16 = vpx_sad16x16_neon;
-    vpx_sad16x16_avg = vpx_sad16x16_avg_c;
-    if (flags & HAS_NEON) vpx_sad16x16_avg = vpx_sad16x16_avg_neon;
-    vpx_sad16x16x4d = vpx_sad16x16x4d_c;
-    if (flags & HAS_NEON) vpx_sad16x16x4d = vpx_sad16x16x4d_neon;
-    vpx_sad16x32 = vpx_sad16x32_c;
-    if (flags & HAS_NEON) vpx_sad16x32 = vpx_sad16x32_neon;
-    vpx_sad16x32_avg = vpx_sad16x32_avg_c;
-    if (flags & HAS_NEON) vpx_sad16x32_avg = vpx_sad16x32_avg_neon;
-    vpx_sad16x32x4d = vpx_sad16x32x4d_c;
-    if (flags & HAS_NEON) vpx_sad16x32x4d = vpx_sad16x32x4d_neon;
-    vpx_sad16x8 = vpx_sad16x8_c;
-    if (flags & HAS_NEON) vpx_sad16x8 = vpx_sad16x8_neon;
-    vpx_sad16x8_avg = vpx_sad16x8_avg_c;
-    if (flags & HAS_NEON) vpx_sad16x8_avg = vpx_sad16x8_avg_neon;
-    vpx_sad16x8x4d = vpx_sad16x8x4d_c;
-    if (flags & HAS_NEON) vpx_sad16x8x4d = vpx_sad16x8x4d_neon;
-    vpx_sad32x16 = vpx_sad32x16_c;
-    if (flags & HAS_NEON) vpx_sad32x16 = vpx_sad32x16_neon;
-    vpx_sad32x16_avg = vpx_sad32x16_avg_c;
-    if (flags & HAS_NEON) vpx_sad32x16_avg = vpx_sad32x16_avg_neon;
-    vpx_sad32x16x4d = vpx_sad32x16x4d_c;
-    if (flags & HAS_NEON) vpx_sad32x16x4d = vpx_sad32x16x4d_neon;
-    vpx_sad32x32 = vpx_sad32x32_c;
-    if (flags & HAS_NEON) vpx_sad32x32 = vpx_sad32x32_neon;
-    vpx_sad32x32_avg = vpx_sad32x32_avg_c;
-    if (flags & HAS_NEON) vpx_sad32x32_avg = vpx_sad32x32_avg_neon;
-    vpx_sad32x32x4d = vpx_sad32x32x4d_c;
-    if (flags & HAS_NEON) vpx_sad32x32x4d = vpx_sad32x32x4d_neon;
-    vpx_sad32x64 = vpx_sad32x64_c;
-    if (flags & HAS_NEON) vpx_sad32x64 = vpx_sad32x64_neon;
-    vpx_sad32x64_avg = vpx_sad32x64_avg_c;
-    if (flags & HAS_NEON) vpx_sad32x64_avg = vpx_sad32x64_avg_neon;
-    vpx_sad32x64x4d = vpx_sad32x64x4d_c;
-    if (flags & HAS_NEON) vpx_sad32x64x4d = vpx_sad32x64x4d_neon;
-    vpx_sad4x4 = vpx_sad4x4_c;
-    if (flags & HAS_NEON) vpx_sad4x4 = vpx_sad4x4_neon;
-    vpx_sad4x4_avg = vpx_sad4x4_avg_c;
-    if (flags & HAS_NEON) vpx_sad4x4_avg = vpx_sad4x4_avg_neon;
-    vpx_sad4x4x4d = vpx_sad4x4x4d_c;
-    if (flags & HAS_NEON) vpx_sad4x4x4d = vpx_sad4x4x4d_neon;
-    vpx_sad4x8 = vpx_sad4x8_c;
-    if (flags & HAS_NEON) vpx_sad4x8 = vpx_sad4x8_neon;
-    vpx_sad4x8_avg = vpx_sad4x8_avg_c;
-    if (flags & HAS_NEON) vpx_sad4x8_avg = vpx_sad4x8_avg_neon;
-    vpx_sad4x8x4d = vpx_sad4x8x4d_c;
-    if (flags & HAS_NEON) vpx_sad4x8x4d = vpx_sad4x8x4d_neon;
-    vpx_sad64x32 = vpx_sad64x32_c;
-    if (flags & HAS_NEON) vpx_sad64x32 = vpx_sad64x32_neon;
-    vpx_sad64x32_avg = vpx_sad64x32_avg_c;
-    if (flags & HAS_NEON) vpx_sad64x32_avg = vpx_sad64x32_avg_neon;
-    vpx_sad64x32x4d = vpx_sad64x32x4d_c;
-    if (flags & HAS_NEON) vpx_sad64x32x4d = vpx_sad64x32x4d_neon;
-    vpx_sad64x64 = vpx_sad64x64_c;
-    if (flags & HAS_NEON) vpx_sad64x64 = vpx_sad64x64_neon;
-    vpx_sad64x64_avg = vpx_sad64x64_avg_c;
-    if (flags & HAS_NEON) vpx_sad64x64_avg = vpx_sad64x64_avg_neon;
-    vpx_sad64x64x4d = vpx_sad64x64x4d_c;
-    if (flags & HAS_NEON) vpx_sad64x64x4d = vpx_sad64x64x4d_neon;
-    vpx_sad8x16 = vpx_sad8x16_c;
-    if (flags & HAS_NEON) vpx_sad8x16 = vpx_sad8x16_neon;
-    vpx_sad8x16_avg = vpx_sad8x16_avg_c;
-    if (flags & HAS_NEON) vpx_sad8x16_avg = vpx_sad8x16_avg_neon;
-    vpx_sad8x16x4d = vpx_sad8x16x4d_c;
-    if (flags & HAS_NEON) vpx_sad8x16x4d = vpx_sad8x16x4d_neon;
-    vpx_sad8x4 = vpx_sad8x4_c;
-    if (flags & HAS_NEON) vpx_sad8x4 = vpx_sad8x4_neon;
-    vpx_sad8x4_avg = vpx_sad8x4_avg_c;
-    if (flags & HAS_NEON) vpx_sad8x4_avg = vpx_sad8x4_avg_neon;
-    vpx_sad8x4x4d = vpx_sad8x4x4d_c;
-    if (flags & HAS_NEON) vpx_sad8x4x4d = vpx_sad8x4x4d_neon;
-    vpx_sad8x8 = vpx_sad8x8_c;
-    if (flags & HAS_NEON) vpx_sad8x8 = vpx_sad8x8_neon;
-    vpx_sad8x8_avg = vpx_sad8x8_avg_c;
-    if (flags & HAS_NEON) vpx_sad8x8_avg = vpx_sad8x8_avg_neon;
-    vpx_sad8x8x4d = vpx_sad8x8x4d_c;
-    if (flags & HAS_NEON) vpx_sad8x8x4d = vpx_sad8x8x4d_neon;
-    vpx_satd = vpx_satd_c;
-    if (flags & HAS_NEON) vpx_satd = vpx_satd_neon;
-    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_neon;
-    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_neon;
-    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_neon;
-    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_neon;
-    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_neon;
-    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_neon;
-    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_neon;
-    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_neon;
-    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_neon;
-    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_neon;
-    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_neon;
-    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_neon;
-    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_neon;
-    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_neon;
-    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_neon;
-    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_neon;
-    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_neon;
-    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_neon;
-    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_neon;
-    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_neon;
-    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_neon;
-    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_neon;
-    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_neon;
-    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_neon;
-    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_neon;
-    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_c;
-    if (flags & HAS_NEON) vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_neon;
-    vpx_subtract_block = vpx_subtract_block_c;
-    if (flags & HAS_NEON) vpx_subtract_block = vpx_subtract_block_neon;
-    vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_c;
-    if (flags & HAS_NEON) vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_neon;
-    vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_c;
-    if (flags & HAS_NEON) vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_neon;
-    vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_c;
-    if (flags & HAS_NEON) vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_neon;
-    vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_c;
-    if (flags & HAS_NEON) vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_neon;
-    vpx_v_predictor_16x16 = vpx_v_predictor_16x16_c;
-    if (flags & HAS_NEON) vpx_v_predictor_16x16 = vpx_v_predictor_16x16_neon;
-    vpx_v_predictor_32x32 = vpx_v_predictor_32x32_c;
-    if (flags & HAS_NEON) vpx_v_predictor_32x32 = vpx_v_predictor_32x32_neon;
-    vpx_v_predictor_4x4 = vpx_v_predictor_4x4_c;
-    if (flags & HAS_NEON) vpx_v_predictor_4x4 = vpx_v_predictor_4x4_neon;
-    vpx_v_predictor_8x8 = vpx_v_predictor_8x8_c;
-    if (flags & HAS_NEON) vpx_v_predictor_8x8 = vpx_v_predictor_8x8_neon;
-    vpx_variance16x16 = vpx_variance16x16_c;
-    if (flags & HAS_NEON) vpx_variance16x16 = vpx_variance16x16_neon;
-    vpx_variance16x32 = vpx_variance16x32_c;
-    if (flags & HAS_NEON) vpx_variance16x32 = vpx_variance16x32_neon;
-    vpx_variance16x8 = vpx_variance16x8_c;
-    if (flags & HAS_NEON) vpx_variance16x8 = vpx_variance16x8_neon;
-    vpx_variance32x16 = vpx_variance32x16_c;
-    if (flags & HAS_NEON) vpx_variance32x16 = vpx_variance32x16_neon;
-    vpx_variance32x32 = vpx_variance32x32_c;
-    if (flags & HAS_NEON) vpx_variance32x32 = vpx_variance32x32_neon;
-    vpx_variance32x64 = vpx_variance32x64_c;
-    if (flags & HAS_NEON) vpx_variance32x64 = vpx_variance32x64_neon;
-    vpx_variance4x4 = vpx_variance4x4_c;
-    if (flags & HAS_NEON) vpx_variance4x4 = vpx_variance4x4_neon;
-    vpx_variance4x8 = vpx_variance4x8_c;
-    if (flags & HAS_NEON) vpx_variance4x8 = vpx_variance4x8_neon;
-    vpx_variance64x32 = vpx_variance64x32_c;
-    if (flags & HAS_NEON) vpx_variance64x32 = vpx_variance64x32_neon;
-    vpx_variance64x64 = vpx_variance64x64_c;
-    if (flags & HAS_NEON) vpx_variance64x64 = vpx_variance64x64_neon;
-    vpx_variance8x16 = vpx_variance8x16_c;
-    if (flags & HAS_NEON) vpx_variance8x16 = vpx_variance8x16_neon;
-    vpx_variance8x4 = vpx_variance8x4_c;
-    if (flags & HAS_NEON) vpx_variance8x4 = vpx_variance8x4_neon;
-    vpx_variance8x8 = vpx_variance8x8_c;
-    if (flags & HAS_NEON) vpx_variance8x8 = vpx_variance8x8_neon;
-    vpx_vector_var = vpx_vector_var_c;
-    if (flags & HAS_NEON) vpx_vector_var = vpx_vector_var_neon;
+  vpx_avg_4x4 = vpx_avg_4x4_c;
+  if (flags & HAS_NEON)
+    vpx_avg_4x4 = vpx_avg_4x4_neon;
+  vpx_avg_8x8 = vpx_avg_8x8_c;
+  if (flags & HAS_NEON)
+    vpx_avg_8x8 = vpx_avg_8x8_neon;
+  vpx_comp_avg_pred = vpx_comp_avg_pred_c;
+  if (flags & HAS_NEON)
+    vpx_comp_avg_pred = vpx_comp_avg_pred_neon;
+  vpx_convolve8 = vpx_convolve8_c;
+  if (flags & HAS_NEON)
+    vpx_convolve8 = vpx_convolve8_neon;
+  vpx_convolve8_avg = vpx_convolve8_avg_c;
+  if (flags & HAS_NEON)
+    vpx_convolve8_avg = vpx_convolve8_avg_neon;
+  vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_c;
+  if (flags & HAS_NEON)
+    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_neon;
+  vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_c;
+  if (flags & HAS_NEON)
+    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_neon;
+  vpx_convolve8_horiz = vpx_convolve8_horiz_c;
+  if (flags & HAS_NEON)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_neon;
+  vpx_convolve8_vert = vpx_convolve8_vert_c;
+  if (flags & HAS_NEON)
+    vpx_convolve8_vert = vpx_convolve8_vert_neon;
+  vpx_convolve_avg = vpx_convolve_avg_c;
+  if (flags & HAS_NEON)
+    vpx_convolve_avg = vpx_convolve_avg_neon;
+  vpx_convolve_copy = vpx_convolve_copy_c;
+  if (flags & HAS_NEON)
+    vpx_convolve_copy = vpx_convolve_copy_neon;
+  vpx_d135_predictor_16x16 = vpx_d135_predictor_16x16_c;
+  if (flags & HAS_NEON)
+    vpx_d135_predictor_16x16 = vpx_d135_predictor_16x16_neon;
+  vpx_d135_predictor_32x32 = vpx_d135_predictor_32x32_c;
+  if (flags & HAS_NEON)
+    vpx_d135_predictor_32x32 = vpx_d135_predictor_32x32_neon;
+  vpx_d135_predictor_4x4 = vpx_d135_predictor_4x4_c;
+  if (flags & HAS_NEON)
+    vpx_d135_predictor_4x4 = vpx_d135_predictor_4x4_neon;
+  vpx_d135_predictor_8x8 = vpx_d135_predictor_8x8_c;
+  if (flags & HAS_NEON)
+    vpx_d135_predictor_8x8 = vpx_d135_predictor_8x8_neon;
+  vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_c;
+  if (flags & HAS_NEON)
+    vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_neon;
+  vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_c;
+  if (flags & HAS_NEON)
+    vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_neon;
+  vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_c;
+  if (flags & HAS_NEON)
+    vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_neon;
+  vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_c;
+  if (flags & HAS_NEON)
+    vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_neon;
+  vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_c;
+  if (flags & HAS_NEON)
+    vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_neon;
+  vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_c;
+  if (flags & HAS_NEON)
+    vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_neon;
+  vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_c;
+  if (flags & HAS_NEON)
+    vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_neon;
+  vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_c;
+  if (flags & HAS_NEON)
+    vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_neon;
+  vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_c;
+  if (flags & HAS_NEON)
+    vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_neon;
+  vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_c;
+  if (flags & HAS_NEON)
+    vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_neon;
+  vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_c;
+  if (flags & HAS_NEON)
+    vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_neon;
+  vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_c;
+  if (flags & HAS_NEON)
+    vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_neon;
+  vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_c;
+  if (flags & HAS_NEON)
+    vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_neon;
+  vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_c;
+  if (flags & HAS_NEON)
+    vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_neon;
+  vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_c;
+  if (flags & HAS_NEON)
+    vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_neon;
+  vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_c;
+  if (flags & HAS_NEON)
+    vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_neon;
+  vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_c;
+  if (flags & HAS_NEON)
+    vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_neon;
+  vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_c;
+  if (flags & HAS_NEON)
+    vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_neon;
+  vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_c;
+  if (flags & HAS_NEON)
+    vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_neon;
+  vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_c;
+  if (flags & HAS_NEON)
+    vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_neon;
+  vpx_fdct16x16 = vpx_fdct16x16_c;
+  if (flags & HAS_NEON)
+    vpx_fdct16x16 = vpx_fdct16x16_neon;
+  vpx_fdct16x16_1 = vpx_fdct16x16_1_c;
+  if (flags & HAS_NEON)
+    vpx_fdct16x16_1 = vpx_fdct16x16_1_neon;
+  vpx_fdct32x32 = vpx_fdct32x32_c;
+  if (flags & HAS_NEON)
+    vpx_fdct32x32 = vpx_fdct32x32_neon;
+  vpx_fdct32x32_1 = vpx_fdct32x32_1_c;
+  if (flags & HAS_NEON)
+    vpx_fdct32x32_1 = vpx_fdct32x32_1_neon;
+  vpx_fdct32x32_rd = vpx_fdct32x32_rd_c;
+  if (flags & HAS_NEON)
+    vpx_fdct32x32_rd = vpx_fdct32x32_rd_neon;
+  vpx_fdct4x4 = vpx_fdct4x4_c;
+  if (flags & HAS_NEON)
+    vpx_fdct4x4 = vpx_fdct4x4_neon;
+  vpx_fdct4x4_1 = vpx_fdct4x4_1_c;
+  if (flags & HAS_NEON)
+    vpx_fdct4x4_1 = vpx_fdct4x4_1_neon;
+  vpx_fdct8x8 = vpx_fdct8x8_c;
+  if (flags & HAS_NEON)
+    vpx_fdct8x8 = vpx_fdct8x8_neon;
+  vpx_fdct8x8_1 = vpx_fdct8x8_1_c;
+  if (flags & HAS_NEON)
+    vpx_fdct8x8_1 = vpx_fdct8x8_1_neon;
+  vpx_get16x16var = vpx_get16x16var_c;
+  if (flags & HAS_NEON)
+    vpx_get16x16var = vpx_get16x16var_neon;
+  vpx_get4x4sse_cs = vpx_get4x4sse_cs_c;
+  if (flags & HAS_NEON)
+    vpx_get4x4sse_cs = vpx_get4x4sse_cs_neon;
+  vpx_get8x8var = vpx_get8x8var_c;
+  if (flags & HAS_NEON)
+    vpx_get8x8var = vpx_get8x8var_neon;
+  vpx_h_predictor_16x16 = vpx_h_predictor_16x16_c;
+  if (flags & HAS_NEON)
+    vpx_h_predictor_16x16 = vpx_h_predictor_16x16_neon;
+  vpx_h_predictor_32x32 = vpx_h_predictor_32x32_c;
+  if (flags & HAS_NEON)
+    vpx_h_predictor_32x32 = vpx_h_predictor_32x32_neon;
+  vpx_h_predictor_4x4 = vpx_h_predictor_4x4_c;
+  if (flags & HAS_NEON)
+    vpx_h_predictor_4x4 = vpx_h_predictor_4x4_neon;
+  vpx_h_predictor_8x8 = vpx_h_predictor_8x8_c;
+  if (flags & HAS_NEON)
+    vpx_h_predictor_8x8 = vpx_h_predictor_8x8_neon;
+  vpx_hadamard_16x16 = vpx_hadamard_16x16_c;
+  if (flags & HAS_NEON)
+    vpx_hadamard_16x16 = vpx_hadamard_16x16_neon;
+  vpx_hadamard_8x8 = vpx_hadamard_8x8_c;
+  if (flags & HAS_NEON)
+    vpx_hadamard_8x8 = vpx_hadamard_8x8_neon;
+  vpx_idct16x16_10_add = vpx_idct16x16_10_add_c;
+  if (flags & HAS_NEON)
+    vpx_idct16x16_10_add = vpx_idct16x16_10_add_neon;
+  vpx_idct16x16_1_add = vpx_idct16x16_1_add_c;
+  if (flags & HAS_NEON)
+    vpx_idct16x16_1_add = vpx_idct16x16_1_add_neon;
+  vpx_idct16x16_256_add = vpx_idct16x16_256_add_c;
+  if (flags & HAS_NEON)
+    vpx_idct16x16_256_add = vpx_idct16x16_256_add_neon;
+  vpx_idct16x16_38_add = vpx_idct16x16_38_add_c;
+  if (flags & HAS_NEON)
+    vpx_idct16x16_38_add = vpx_idct16x16_38_add_neon;
+  vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_c;
+  if (flags & HAS_NEON)
+    vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_neon;
+  vpx_idct32x32_135_add = vpx_idct32x32_135_add_c;
+  if (flags & HAS_NEON)
+    vpx_idct32x32_135_add = vpx_idct32x32_135_add_neon;
+  vpx_idct32x32_1_add = vpx_idct32x32_1_add_c;
+  if (flags & HAS_NEON)
+    vpx_idct32x32_1_add = vpx_idct32x32_1_add_neon;
+  vpx_idct32x32_34_add = vpx_idct32x32_34_add_c;
+  if (flags & HAS_NEON)
+    vpx_idct32x32_34_add = vpx_idct32x32_34_add_neon;
+  vpx_idct4x4_16_add = vpx_idct4x4_16_add_c;
+  if (flags & HAS_NEON)
+    vpx_idct4x4_16_add = vpx_idct4x4_16_add_neon;
+  vpx_idct4x4_1_add = vpx_idct4x4_1_add_c;
+  if (flags & HAS_NEON)
+    vpx_idct4x4_1_add = vpx_idct4x4_1_add_neon;
+  vpx_idct8x8_12_add = vpx_idct8x8_12_add_c;
+  if (flags & HAS_NEON)
+    vpx_idct8x8_12_add = vpx_idct8x8_12_add_neon;
+  vpx_idct8x8_1_add = vpx_idct8x8_1_add_c;
+  if (flags & HAS_NEON)
+    vpx_idct8x8_1_add = vpx_idct8x8_1_add_neon;
+  vpx_idct8x8_64_add = vpx_idct8x8_64_add_c;
+  if (flags & HAS_NEON)
+    vpx_idct8x8_64_add = vpx_idct8x8_64_add_neon;
+  vpx_int_pro_col = vpx_int_pro_col_c;
+  if (flags & HAS_NEON)
+    vpx_int_pro_col = vpx_int_pro_col_neon;
+  vpx_int_pro_row = vpx_int_pro_row_c;
+  if (flags & HAS_NEON)
+    vpx_int_pro_row = vpx_int_pro_row_neon;
+  vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_c;
+  if (flags & HAS_NEON)
+    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_neon;
+  vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_c;
+  if (flags & HAS_NEON)
+    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_neon;
+  vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_c;
+  if (flags & HAS_NEON)
+    vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_neon;
+  vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_c;
+  if (flags & HAS_NEON)
+    vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_neon;
+  vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_c;
+  if (flags & HAS_NEON)
+    vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_neon;
+  vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_c;
+  if (flags & HAS_NEON)
+    vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_neon;
+  vpx_lpf_vertical_16 = vpx_lpf_vertical_16_c;
+  if (flags & HAS_NEON)
+    vpx_lpf_vertical_16 = vpx_lpf_vertical_16_neon;
+  vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_c;
+  if (flags & HAS_NEON)
+    vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_neon;
+  vpx_lpf_vertical_4 = vpx_lpf_vertical_4_c;
+  if (flags & HAS_NEON)
+    vpx_lpf_vertical_4 = vpx_lpf_vertical_4_neon;
+  vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_c;
+  if (flags & HAS_NEON)
+    vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_neon;
+  vpx_lpf_vertical_8 = vpx_lpf_vertical_8_c;
+  if (flags & HAS_NEON)
+    vpx_lpf_vertical_8 = vpx_lpf_vertical_8_neon;
+  vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_c;
+  if (flags & HAS_NEON)
+    vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_neon;
+  vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_c;
+  if (flags & HAS_NEON)
+    vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_neon;
+  vpx_mbpost_proc_down = vpx_mbpost_proc_down_c;
+  if (flags & HAS_NEON)
+    vpx_mbpost_proc_down = vpx_mbpost_proc_down_neon;
+  vpx_minmax_8x8 = vpx_minmax_8x8_c;
+  if (flags & HAS_NEON)
+    vpx_minmax_8x8 = vpx_minmax_8x8_neon;
+  vpx_mse16x16 = vpx_mse16x16_c;
+  if (flags & HAS_NEON)
+    vpx_mse16x16 = vpx_mse16x16_neon;
+  vpx_post_proc_down_and_across_mb_row = vpx_post_proc_down_and_across_mb_row_c;
+  if (flags & HAS_NEON)
+    vpx_post_proc_down_and_across_mb_row =
+        vpx_post_proc_down_and_across_mb_row_neon;
+  vpx_quantize_b = vpx_quantize_b_c;
+  if (flags & HAS_NEON)
+    vpx_quantize_b = vpx_quantize_b_neon;
+  vpx_sad16x16 = vpx_sad16x16_c;
+  if (flags & HAS_NEON)
+    vpx_sad16x16 = vpx_sad16x16_neon;
+  vpx_sad16x16_avg = vpx_sad16x16_avg_c;
+  if (flags & HAS_NEON)
+    vpx_sad16x16_avg = vpx_sad16x16_avg_neon;
+  vpx_sad16x16x4d = vpx_sad16x16x4d_c;
+  if (flags & HAS_NEON)
+    vpx_sad16x16x4d = vpx_sad16x16x4d_neon;
+  vpx_sad16x32 = vpx_sad16x32_c;
+  if (flags & HAS_NEON)
+    vpx_sad16x32 = vpx_sad16x32_neon;
+  vpx_sad16x32_avg = vpx_sad16x32_avg_c;
+  if (flags & HAS_NEON)
+    vpx_sad16x32_avg = vpx_sad16x32_avg_neon;
+  vpx_sad16x32x4d = vpx_sad16x32x4d_c;
+  if (flags & HAS_NEON)
+    vpx_sad16x32x4d = vpx_sad16x32x4d_neon;
+  vpx_sad16x8 = vpx_sad16x8_c;
+  if (flags & HAS_NEON)
+    vpx_sad16x8 = vpx_sad16x8_neon;
+  vpx_sad16x8_avg = vpx_sad16x8_avg_c;
+  if (flags & HAS_NEON)
+    vpx_sad16x8_avg = vpx_sad16x8_avg_neon;
+  vpx_sad16x8x4d = vpx_sad16x8x4d_c;
+  if (flags & HAS_NEON)
+    vpx_sad16x8x4d = vpx_sad16x8x4d_neon;
+  vpx_sad32x16 = vpx_sad32x16_c;
+  if (flags & HAS_NEON)
+    vpx_sad32x16 = vpx_sad32x16_neon;
+  vpx_sad32x16_avg = vpx_sad32x16_avg_c;
+  if (flags & HAS_NEON)
+    vpx_sad32x16_avg = vpx_sad32x16_avg_neon;
+  vpx_sad32x16x4d = vpx_sad32x16x4d_c;
+  if (flags & HAS_NEON)
+    vpx_sad32x16x4d = vpx_sad32x16x4d_neon;
+  vpx_sad32x32 = vpx_sad32x32_c;
+  if (flags & HAS_NEON)
+    vpx_sad32x32 = vpx_sad32x32_neon;
+  vpx_sad32x32_avg = vpx_sad32x32_avg_c;
+  if (flags & HAS_NEON)
+    vpx_sad32x32_avg = vpx_sad32x32_avg_neon;
+  vpx_sad32x32x4d = vpx_sad32x32x4d_c;
+  if (flags & HAS_NEON)
+    vpx_sad32x32x4d = vpx_sad32x32x4d_neon;
+  vpx_sad32x64 = vpx_sad32x64_c;
+  if (flags & HAS_NEON)
+    vpx_sad32x64 = vpx_sad32x64_neon;
+  vpx_sad32x64_avg = vpx_sad32x64_avg_c;
+  if (flags & HAS_NEON)
+    vpx_sad32x64_avg = vpx_sad32x64_avg_neon;
+  vpx_sad32x64x4d = vpx_sad32x64x4d_c;
+  if (flags & HAS_NEON)
+    vpx_sad32x64x4d = vpx_sad32x64x4d_neon;
+  vpx_sad4x4 = vpx_sad4x4_c;
+  if (flags & HAS_NEON)
+    vpx_sad4x4 = vpx_sad4x4_neon;
+  vpx_sad4x4_avg = vpx_sad4x4_avg_c;
+  if (flags & HAS_NEON)
+    vpx_sad4x4_avg = vpx_sad4x4_avg_neon;
+  vpx_sad4x4x4d = vpx_sad4x4x4d_c;
+  if (flags & HAS_NEON)
+    vpx_sad4x4x4d = vpx_sad4x4x4d_neon;
+  vpx_sad4x8 = vpx_sad4x8_c;
+  if (flags & HAS_NEON)
+    vpx_sad4x8 = vpx_sad4x8_neon;
+  vpx_sad4x8_avg = vpx_sad4x8_avg_c;
+  if (flags & HAS_NEON)
+    vpx_sad4x8_avg = vpx_sad4x8_avg_neon;
+  vpx_sad4x8x4d = vpx_sad4x8x4d_c;
+  if (flags & HAS_NEON)
+    vpx_sad4x8x4d = vpx_sad4x8x4d_neon;
+  vpx_sad64x32 = vpx_sad64x32_c;
+  if (flags & HAS_NEON)
+    vpx_sad64x32 = vpx_sad64x32_neon;
+  vpx_sad64x32_avg = vpx_sad64x32_avg_c;
+  if (flags & HAS_NEON)
+    vpx_sad64x32_avg = vpx_sad64x32_avg_neon;
+  vpx_sad64x32x4d = vpx_sad64x32x4d_c;
+  if (flags & HAS_NEON)
+    vpx_sad64x32x4d = vpx_sad64x32x4d_neon;
+  vpx_sad64x64 = vpx_sad64x64_c;
+  if (flags & HAS_NEON)
+    vpx_sad64x64 = vpx_sad64x64_neon;
+  vpx_sad64x64_avg = vpx_sad64x64_avg_c;
+  if (flags & HAS_NEON)
+    vpx_sad64x64_avg = vpx_sad64x64_avg_neon;
+  vpx_sad64x64x4d = vpx_sad64x64x4d_c;
+  if (flags & HAS_NEON)
+    vpx_sad64x64x4d = vpx_sad64x64x4d_neon;
+  vpx_sad8x16 = vpx_sad8x16_c;
+  if (flags & HAS_NEON)
+    vpx_sad8x16 = vpx_sad8x16_neon;
+  vpx_sad8x16_avg = vpx_sad8x16_avg_c;
+  if (flags & HAS_NEON)
+    vpx_sad8x16_avg = vpx_sad8x16_avg_neon;
+  vpx_sad8x16x4d = vpx_sad8x16x4d_c;
+  if (flags & HAS_NEON)
+    vpx_sad8x16x4d = vpx_sad8x16x4d_neon;
+  vpx_sad8x4 = vpx_sad8x4_c;
+  if (flags & HAS_NEON)
+    vpx_sad8x4 = vpx_sad8x4_neon;
+  vpx_sad8x4_avg = vpx_sad8x4_avg_c;
+  if (flags & HAS_NEON)
+    vpx_sad8x4_avg = vpx_sad8x4_avg_neon;
+  vpx_sad8x4x4d = vpx_sad8x4x4d_c;
+  if (flags & HAS_NEON)
+    vpx_sad8x4x4d = vpx_sad8x4x4d_neon;
+  vpx_sad8x8 = vpx_sad8x8_c;
+  if (flags & HAS_NEON)
+    vpx_sad8x8 = vpx_sad8x8_neon;
+  vpx_sad8x8_avg = vpx_sad8x8_avg_c;
+  if (flags & HAS_NEON)
+    vpx_sad8x8_avg = vpx_sad8x8_avg_neon;
+  vpx_sad8x8x4d = vpx_sad8x8x4d_c;
+  if (flags & HAS_NEON)
+    vpx_sad8x8x4d = vpx_sad8x8x4d_neon;
+  vpx_satd = vpx_satd_c;
+  if (flags & HAS_NEON)
+    vpx_satd = vpx_satd_neon;
+  vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_neon;
+  vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_neon;
+  vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_neon;
+  vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_neon;
+  vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_neon;
+  vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_neon;
+  vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_neon;
+  vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_neon;
+  vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_neon;
+  vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_neon;
+  vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_neon;
+  vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_neon;
+  vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_neon;
+  vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_neon;
+  vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_neon;
+  vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_neon;
+  vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_neon;
+  vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_neon;
+  vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_neon;
+  vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_neon;
+  vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_neon;
+  vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_neon;
+  vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_neon;
+  vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_neon;
+  vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_neon;
+  vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_c;
+  if (flags & HAS_NEON)
+    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_neon;
+  vpx_subtract_block = vpx_subtract_block_c;
+  if (flags & HAS_NEON)
+    vpx_subtract_block = vpx_subtract_block_neon;
+  vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_c;
+  if (flags & HAS_NEON)
+    vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_neon;
+  vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_c;
+  if (flags & HAS_NEON)
+    vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_neon;
+  vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_c;
+  if (flags & HAS_NEON)
+    vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_neon;
+  vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_c;
+  if (flags & HAS_NEON)
+    vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_neon;
+  vpx_v_predictor_16x16 = vpx_v_predictor_16x16_c;
+  if (flags & HAS_NEON)
+    vpx_v_predictor_16x16 = vpx_v_predictor_16x16_neon;
+  vpx_v_predictor_32x32 = vpx_v_predictor_32x32_c;
+  if (flags & HAS_NEON)
+    vpx_v_predictor_32x32 = vpx_v_predictor_32x32_neon;
+  vpx_v_predictor_4x4 = vpx_v_predictor_4x4_c;
+  if (flags & HAS_NEON)
+    vpx_v_predictor_4x4 = vpx_v_predictor_4x4_neon;
+  vpx_v_predictor_8x8 = vpx_v_predictor_8x8_c;
+  if (flags & HAS_NEON)
+    vpx_v_predictor_8x8 = vpx_v_predictor_8x8_neon;
+  vpx_variance16x16 = vpx_variance16x16_c;
+  if (flags & HAS_NEON)
+    vpx_variance16x16 = vpx_variance16x16_neon;
+  vpx_variance16x32 = vpx_variance16x32_c;
+  if (flags & HAS_NEON)
+    vpx_variance16x32 = vpx_variance16x32_neon;
+  vpx_variance16x8 = vpx_variance16x8_c;
+  if (flags & HAS_NEON)
+    vpx_variance16x8 = vpx_variance16x8_neon;
+  vpx_variance32x16 = vpx_variance32x16_c;
+  if (flags & HAS_NEON)
+    vpx_variance32x16 = vpx_variance32x16_neon;
+  vpx_variance32x32 = vpx_variance32x32_c;
+  if (flags & HAS_NEON)
+    vpx_variance32x32 = vpx_variance32x32_neon;
+  vpx_variance32x64 = vpx_variance32x64_c;
+  if (flags & HAS_NEON)
+    vpx_variance32x64 = vpx_variance32x64_neon;
+  vpx_variance4x4 = vpx_variance4x4_c;
+  if (flags & HAS_NEON)
+    vpx_variance4x4 = vpx_variance4x4_neon;
+  vpx_variance4x8 = vpx_variance4x8_c;
+  if (flags & HAS_NEON)
+    vpx_variance4x8 = vpx_variance4x8_neon;
+  vpx_variance64x32 = vpx_variance64x32_c;
+  if (flags & HAS_NEON)
+    vpx_variance64x32 = vpx_variance64x32_neon;
+  vpx_variance64x64 = vpx_variance64x64_c;
+  if (flags & HAS_NEON)
+    vpx_variance64x64 = vpx_variance64x64_neon;
+  vpx_variance8x16 = vpx_variance8x16_c;
+  if (flags & HAS_NEON)
+    vpx_variance8x16 = vpx_variance8x16_neon;
+  vpx_variance8x4 = vpx_variance8x4_c;
+  if (flags & HAS_NEON)
+    vpx_variance8x4 = vpx_variance8x4_neon;
+  vpx_variance8x8 = vpx_variance8x8_c;
+  if (flags & HAS_NEON)
+    vpx_variance8x8 = vpx_variance8x8_neon;
+  vpx_vector_var = vpx_vector_var_c;
+  if (flags & HAS_NEON)
+    vpx_vector_var = vpx_vector_var_neon;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_scale_rtcd.h b/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_scale_rtcd.h
index 515ce27..564cb3b 100644
--- a/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm-neon-cpu-detect/vpx_scale_rtcd.h
@@ -13,43 +13,71 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
@@ -58,12 +86,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm-neon/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm-neon/vp8_rtcd.h b/third_party/libvpx/source/config/linux/arm-neon/vp8_rtcd.h
index 6a7f92c..c6222d0 100644
--- a/third_party/libvpx/source/config/linux/arm-neon/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm-neon/vp8_rtcd.h
@@ -26,174 +26,455 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+void vp8_bilinear_predict16x16_neon(unsigned char* src,
+                                    int src_pitch,
+                                    int xofst,
+                                    int yofst,
+                                    unsigned char* dst,
+                                    int dst_pitch);
 #define vp8_bilinear_predict16x16 vp8_bilinear_predict16x16_neon
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict4x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict4x4_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_bilinear_predict4x4 vp8_bilinear_predict4x4_neon
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x4_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_bilinear_predict8x4 vp8_bilinear_predict8x4_neon
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x8_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_bilinear_predict8x8 vp8_bilinear_predict8x8_neon
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
 #define vp8_block_error vp8_block_error_c
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem16x16_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+void vp8_copy_mem16x16_neon(unsigned char* src,
+                            int src_pitch,
+                            unsigned char* dst,
+                            int dst_pitch);
 #define vp8_copy_mem16x16 vp8_copy_mem16x16_neon
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x4_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x4_neon(unsigned char* src,
+                          int src_pitch,
+                          unsigned char* dst,
+                          int dst_pitch);
 #define vp8_copy_mem8x4 vp8_copy_mem8x4_neon
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x8_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x8_neon(unsigned char* src,
+                          int src_pitch,
+                          unsigned char* dst,
+                          int dst_pitch);
 #define vp8_copy_mem8x8 vp8_copy_mem8x8_neon
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-void vp8_dc_only_idct_add_neon(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_dc_only_idct_add_neon(short input,
+                               unsigned char* pred,
+                               int pred_stride,
+                               unsigned char* dst,
+                               int dst_stride);
 #define vp8_dc_only_idct_add vp8_dc_only_idct_add_neon
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_neon(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
+int vp8_denoiser_filter_neon(unsigned char* mc_running_avg_y,
+                             int mc_avg_y_stride,
+                             unsigned char* running_avg_y,
+                             int avg_y_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
 #define vp8_denoiser_filter vp8_denoiser_filter_neon
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_uv_neon(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+int vp8_denoiser_filter_uv_neon(unsigned char* mc_running_avg,
+                                int mc_avg_stride,
+                                unsigned char* running_avg,
+                                int avg_stride,
+                                unsigned char* sig,
+                                int sig_stride,
+                                unsigned int motion_magnitude,
+                                int increase_denoising);
 #define vp8_denoiser_filter_uv vp8_denoiser_filter_uv_neon
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
-void vp8_dequant_idct_add_neon(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
+void vp8_dequant_idct_add_neon(short* input,
+                               short* dq,
+                               unsigned char* output,
+                               int stride);
 #define vp8_dequant_idct_add vp8_dequant_idct_add_neon
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-void vp8_dequant_idct_add_uv_block_neon(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
+void vp8_dequant_idct_add_uv_block_neon(short* q,
+                                        short* dq,
+                                        unsigned char* dst_u,
+                                        unsigned char* dst_v,
+                                        int stride,
+                                        char* eobs);
 #define vp8_dequant_idct_add_uv_block vp8_dequant_idct_add_uv_block_neon
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-void vp8_dequant_idct_add_y_block_neon(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
+void vp8_dequant_idct_add_y_block_neon(short* q,
+                                       short* dq,
+                                       unsigned char* dst,
+                                       int stride,
+                                       char* eobs);
 #define vp8_dequant_idct_add_y_block vp8_dequant_idct_add_y_block_neon
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
-void vp8_dequantize_b_neon(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
+void vp8_dequantize_b_neon(struct blockd*, short* dqc);
 #define vp8_dequantize_b vp8_dequantize_b_neon
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
 #define vp8_diamond_search_sad vp8_diamond_search_sad_c
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
-void vp8_fast_quantize_b_neon(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
+void vp8_fast_quantize_b_neon(struct block*, struct blockd*);
 #define vp8_fast_quantize_b vp8_fast_quantize_b_neon
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp8_filter_by_weight16x16 vp8_filter_by_weight16x16_c
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight8x8 vp8_filter_by_weight8x8_c
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
 #define vp8_full_search_sad vp8_full_search_sad_c
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bh_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bh_neon(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
 #define vp8_loop_filter_bh vp8_loop_filter_bh_neon
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bv_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bv_neon(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
 #define vp8_loop_filter_bv vp8_loop_filter_bv_neon
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbh_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbh_neon(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbh vp8_loop_filter_mbh_neon
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbv_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbv_neon(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbv vp8_loop_filter_mbv_neon
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bhs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bhs_neon(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_bh vp8_loop_filter_bhs_neon
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bvs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bvs_neon(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_bv vp8_loop_filter_bvs_neon
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_mbhs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
+void vp8_loop_filter_mbhs_neon(unsigned char* y,
+                               int ystride,
+                               const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbh vp8_loop_filter_mbhs_neon
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_mbvs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
+void vp8_loop_filter_mbvs_neon(unsigned char* y,
+                               int ystride,
+                               const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbv vp8_loop_filter_mbvs_neon
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
 #define vp8_mbblock_error vp8_mbblock_error_c
 
-int vp8_mbuverror_c(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
 #define vp8_mbuverror vp8_mbuverror_c
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
 #define vp8_refining_search_sad vp8_refining_search_sad_c
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
 #define vp8_regular_quantize_b vp8_regular_quantize_b_c
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct4x4_neon(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct4x4_neon(short* input, short* output, int pitch);
 #define vp8_short_fdct4x4 vp8_short_fdct4x4_neon
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct8x4_neon(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct8x4_neon(short* input, short* output, int pitch);
 #define vp8_short_fdct8x4 vp8_short_fdct8x4_neon
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-void vp8_short_idct4x4llm_neon(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_short_idct4x4llm_neon(short* input,
+                               unsigned char* pred,
+                               int pitch,
+                               unsigned char* dst,
+                               int dst_stride);
 #define vp8_short_idct4x4llm vp8_short_idct4x4llm_neon
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
-void vp8_short_inv_walsh4x4_neon(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
+void vp8_short_inv_walsh4x4_neon(short* input, short* output);
 #define vp8_short_inv_walsh4x4 vp8_short_inv_walsh4x4_neon
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
-void vp8_short_walsh4x4_neon(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
+void vp8_short_walsh4x4_neon(short* input, short* output, int pitch);
 #define vp8_short_walsh4x4 vp8_short_walsh4x4_neon
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict16x16_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_sixtap_predict16x16 vp8_sixtap_predict16x16_neon
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict4x4_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
 #define vp8_sixtap_predict4x4 vp8_sixtap_predict4x4_neon
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x4_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
 #define vp8_sixtap_predict8x4 vp8_sixtap_predict8x4_neon
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x8_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
 #define vp8_sixtap_predict8x8 vp8_sixtap_predict8x8_neon
 
 void vp8_rtcd(void);
@@ -202,12 +483,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm-neon/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm-neon/vp9_rtcd.h b/third_party/libvpx/source/config/linux/arm-neon/vp9_rtcd.h
index a0f86ea..2ff413b 100644
--- a/third_party/libvpx/source/config/linux/arm-neon/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm-neon/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,64 +30,192 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
 #define vp9_block_error vp9_block_error_c
 
-int64_t vp9_block_error_fp_c(const int16_t *coeff, const int16_t *dqcoeff, int block_size);
-int64_t vp9_block_error_fp_neon(const int16_t *coeff, const int16_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const int16_t* coeff,
+                             const int16_t* dqcoeff,
+                             int block_size);
+int64_t vp9_block_error_fp_neon(const int16_t* coeff,
+                                const int16_t* dqcoeff,
+                                int block_size);
 #define vp9_block_error_fp vp9_block_error_fp_neon
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-int vp9_denoiser_filter_neon(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
+int vp9_denoiser_filter_neon(const uint8_t* sig,
+                             int sig_stride,
+                             const uint8_t* mc_avg,
+                             int mc_avg_stride,
+                             uint8_t* avg,
+                             int avg_stride,
+                             int increase_denoising,
+                             BLOCK_SIZE bs,
+                             int motion_magnitude);
 #define vp9_denoiser_filter vp9_denoiser_filter_neon
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
 #define vp9_diamond_search_sad vp9_diamond_search_sad_c
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_fdct8x8_quant_neon(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+void vp9_fdct8x8_quant_neon(const int16_t* input,
+                            int stride,
+                            tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vp9_fdct8x8_quant vp9_fdct8x8_quant_neon
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
 #define vp9_fht16x16 vp9_fht16x16_c
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht4x4 vp9_fht4x4_c
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht8x8 vp9_fht8x8_c
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp9_filter_by_weight16x16 vp9_filter_by_weight16x16_c
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp9_filter_by_weight8x8 vp9_filter_by_weight8x8_c
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_fwht4x4 vp9_fwht4x4_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
 #define vp9_iht16x16_256_add vp9_iht16x16_256_add_c
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht4x4_16_add_neon(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht4x4_16_add_neon(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
 #define vp9_iht4x4_16_add vp9_iht4x4_16_add_neon
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht8x8_64_add_neon(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht8x8_64_add_neon(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
 #define vp9_iht8x8_64_add vp9_iht8x8_64_add_neon
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_neon(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
+void vp9_quantize_fp_neon(const tran_low_t* coeff_ptr,
+                          intptr_t n_coeffs,
+                          int skip_block,
+                          const int16_t* round_ptr,
+                          const int16_t* quant_ptr,
+                          tran_low_t* qcoeff_ptr,
+                          tran_low_t* dqcoeff_ptr,
+                          const int16_t* dequant_ptr,
+                          uint16_t* eob_ptr,
+                          const int16_t* scan,
+                          const int16_t* iscan);
 #define vp9_quantize_fp vp9_quantize_fp_neon
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vp9_quantize_fp_32x32 vp9_quantize_fp_32x32_c
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
 #define vp9_scale_and_extend_frame vp9_scale_and_extend_frame_c
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
 #define vp9_temporal_filter_apply vp9_temporal_filter_apply_c
 
 void vp9_rtcd(void);
@@ -96,12 +224,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm-neon/vpx_config.asm

diff --git a/third_party/libvpx/source/config/linux/arm-neon/vpx_config.asm b/third_party/libvpx/source/config/linux/arm-neon/vpx_config.asm
index a2ac8c9..03489fe 100644
--- a/third_party/libvpx/source/config/linux/arm-neon/vpx_config.asm
+++ b/third_party/libvpx/source/config/linux/arm-neon/vpx_config.asm
@@ -21,6 +21,7 @@
 .equ HAVE_AVX ,  0
 .equ HAVE_AVX2 ,  0
 .equ HAVE_VSX ,  0
+.equ HAVE_MMI ,  0
 .equ HAVE_VPX_PORTS ,  1
 .equ HAVE_PTHREAD_H ,  1
 .equ HAVE_UNISTD_H ,  0

third_party/libvpx/source/config/linux/arm-neon/vpx_config.h

diff --git a/third_party/libvpx/source/config/linux/arm-neon/vpx_config.h b/third_party/libvpx/source/config/linux/arm-neon/vpx_config.h
index b33278b..a6042f62 100644
--- a/third_party/libvpx/source/config/linux/arm-neon/vpx_config.h
+++ b/third_party/libvpx/source/config/linux/arm-neon/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 0
 #define HAVE_AVX2 0
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/linux/arm-neon/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm-neon/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/linux/arm-neon/vpx_dsp_rtcd.h
index c694f53..ae6787f 100644
--- a/third_party/libvpx/source/config/linux/arm-neon/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm-neon/vpx_dsp_rtcd.h
@@ -14,843 +14,2400 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
-unsigned int vpx_avg_4x4_neon(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
+unsigned int vpx_avg_4x4_neon(const uint8_t*, int p);
 #define vpx_avg_4x4 vpx_avg_4x4_neon
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
-unsigned int vpx_avg_8x8_neon(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
+unsigned int vpx_avg_8x8_neon(const uint8_t*, int p);
 #define vpx_avg_8x8 vpx_avg_8x8_neon
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-void vpx_comp_avg_pred_neon(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
+void vpx_comp_avg_pred_neon(uint8_t* comp_pred,
+                            const uint8_t* pred,
+                            int width,
+                            int height,
+                            const uint8_t* ref,
+                            int ref_stride);
 #define vpx_comp_avg_pred vpx_comp_avg_pred_neon
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_convolve8_neon(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_convolve8 vpx_convolve8_neon
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avg_neon(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_convolve8_avg vpx_convolve8_avg_neon
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_avg_horiz_neon(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 #define vpx_convolve8_avg_horiz vpx_convolve8_avg_horiz_neon
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_avg_vert_neon(const uint8_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h);
 #define vpx_convolve8_avg_vert vpx_convolve8_avg_vert_neon
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+void vpx_convolve8_horiz_neon(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
 #define vpx_convolve8_horiz vpx_convolve8_horiz_neon
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
+void vpx_convolve8_vert_neon(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
 #define vpx_convolve8_vert vpx_convolve8_vert_neon
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_avg_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve_avg_neon(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_convolve_avg vpx_convolve_avg_neon
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_copy_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve_copy_neon(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_convolve_copy vpx_convolve_copy_neon
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d135_predictor_16x16_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_neon
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d135_predictor_32x32_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_neon
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d135_predictor_4x4_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_neon
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d135_predictor_8x8_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_neon
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_16x16 vpx_d153_predictor_16x16_c
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_32x32 vpx_d153_predictor_32x32_c
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_4x4 vpx_d153_predictor_4x4_c
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_8x8 vpx_d153_predictor_8x8_c
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_16x16 vpx_d207_predictor_16x16_c
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_32x32 vpx_d207_predictor_32x32_c
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_4x4 vpx_d207_predictor_4x4_c
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_8x8 vpx_d207_predictor_8x8_c
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_16x16_neon(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_d45_predictor_16x16 vpx_d45_predictor_16x16_neon
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_32x32_neon(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_d45_predictor_32x32 vpx_d45_predictor_32x32_neon
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_4x4_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d45_predictor_4x4 vpx_d45_predictor_4x4_neon
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_8x8_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d45_predictor_8x8 vpx_d45_predictor_8x8_neon
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_16x16 vpx_d63_predictor_16x16_c
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_32x32 vpx_d63_predictor_32x32_c
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_4x4 vpx_d63_predictor_4x4_c
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_8x8 vpx_d63_predictor_8x8_c
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_16x16_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_128_predictor_16x16 vpx_dc_128_predictor_16x16_neon
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_32x32_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_128_predictor_32x32 vpx_dc_128_predictor_32x32_neon
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_4x4_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_128_predictor_4x4 vpx_dc_128_predictor_4x4_neon
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_8x8_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_128_predictor_8x8 vpx_dc_128_predictor_8x8_neon
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_16x16_neon(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
 #define vpx_dc_left_predictor_16x16 vpx_dc_left_predictor_16x16_neon
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_32x32_neon(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
 #define vpx_dc_left_predictor_32x32 vpx_dc_left_predictor_32x32_neon
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_4x4_neon(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
 #define vpx_dc_left_predictor_4x4 vpx_dc_left_predictor_4x4_neon
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_8x8_neon(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
 #define vpx_dc_left_predictor_8x8 vpx_dc_left_predictor_8x8_neon
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_16x16_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_predictor_16x16 vpx_dc_predictor_16x16_neon
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_32x32_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_predictor_32x32 vpx_dc_predictor_32x32_neon
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_4x4_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_dc_predictor_4x4 vpx_dc_predictor_4x4_neon
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_8x8_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_dc_predictor_8x8 vpx_dc_predictor_8x8_neon
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_16x16_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_top_predictor_16x16 vpx_dc_top_predictor_16x16_neon
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_32x32_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_top_predictor_32x32 vpx_dc_top_predictor_32x32_neon
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_4x4_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_top_predictor_4x4 vpx_dc_top_predictor_4x4_neon
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_8x8_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_top_predictor_8x8 vpx_dc_top_predictor_8x8_neon
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16 vpx_fdct16x16_neon
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16_1 vpx_fdct16x16_1_neon
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32 vpx_fdct32x32_neon
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_1 vpx_fdct32x32_1_neon
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_rd_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_rd_neon(const int16_t* input,
+                           tran_low_t* output,
+                           int stride);
 #define vpx_fdct32x32_rd vpx_fdct32x32_rd_neon
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4 vpx_fdct4x4_neon
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4_1 vpx_fdct4x4_1_neon
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8 vpx_fdct8x8_neon
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8_1 vpx_fdct8x8_1_neon
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
+void vpx_get16x16var_neon(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
 #define vpx_get16x16var vpx_get16x16var_neon
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
-unsigned int vpx_get4x4sse_cs_neon(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
+unsigned int vpx_get4x4sse_cs_neon(const unsigned char* src_ptr,
+                                   int source_stride,
+                                   const unsigned char* ref_ptr,
+                                   int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_neon
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get8x8var_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
+void vpx_get8x8var_neon(const uint8_t* src_ptr,
+                        int source_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        unsigned int* sse,
+                        int* sum);
 #define vpx_get8x8var vpx_get8x8var_neon
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
 #define vpx_get_mb_ss vpx_get_mb_ss_c
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_16x16_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_h_predictor_16x16 vpx_h_predictor_16x16_neon
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_32x32_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_h_predictor_32x32 vpx_h_predictor_32x32_neon
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_4x4_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_h_predictor_4x4 vpx_h_predictor_4x4_neon
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_8x8_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_h_predictor_8x8 vpx_h_predictor_8x8_neon
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
-void vpx_hadamard_16x16_neon(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          int16_t* coeff);
+void vpx_hadamard_16x16_neon(const int16_t* src_diff,
+                             int src_stride,
+                             int16_t* coeff);
 #define vpx_hadamard_16x16 vpx_hadamard_16x16_neon
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
-void vpx_hadamard_8x8_neon(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        int16_t* coeff);
+void vpx_hadamard_8x8_neon(const int16_t* src_diff,
+                           int src_stride,
+                           int16_t* coeff);
 #define vpx_hadamard_8x8 vpx_hadamard_8x8_neon
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_10_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_10_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct16x16_10_add vpx_idct16x16_10_add_neon
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_1_add_neon(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct16x16_1_add vpx_idct16x16_1_add_neon
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_256_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct16x16_256_add_neon(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
 #define vpx_idct16x16_256_add vpx_idct16x16_256_add_neon
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_38_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_38_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct16x16_38_add vpx_idct16x16_38_add_neon
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+void vpx_idct32x32_1024_add_neon(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
 #define vpx_idct32x32_1024_add vpx_idct32x32_1024_add_neon
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_135_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct32x32_135_add_neon(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
 #define vpx_idct32x32_135_add vpx_idct32x32_135_add_neon
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_1_add_neon(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct32x32_1_add vpx_idct32x32_1_add_neon
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_34_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct32x32_34_add vpx_idct32x32_34_add_neon
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_16_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_16_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct4x4_16_add vpx_idct4x4_16_add_neon
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_1_add_neon(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_1_add vpx_idct4x4_1_add_neon
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_12_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct8x8_12_add vpx_idct8x8_12_add_neon
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_1_add_neon(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_1_add vpx_idct8x8_1_add_neon
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_64_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_64_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct8x8_64_add vpx_idct8x8_64_add_neon
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
-int16_t vpx_int_pro_col_neon(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
+int16_t vpx_int_pro_col_neon(const uint8_t* ref, const int width);
 #define vpx_int_pro_col vpx_int_pro_col_neon
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-void vpx_int_pro_row_neon(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
+void vpx_int_pro_row_neon(int16_t* hbuf,
+                          const uint8_t* ref,
+                          const int ref_stride,
+                          const int height);
 #define vpx_int_pro_row vpx_int_pro_row_neon
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_16_add vpx_iwht4x4_16_add_c
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+void vpx_lpf_horizontal_16_neon(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
 #define vpx_lpf_horizontal_16 vpx_lpf_horizontal_16_neon
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_neon(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
 #define vpx_lpf_horizontal_16_dual vpx_lpf_horizontal_16_dual_neon
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_4_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_4_neon(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
 #define vpx_lpf_horizontal_4 vpx_lpf_horizontal_4_neon
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_4_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_4_dual_neon(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
 #define vpx_lpf_horizontal_4_dual vpx_lpf_horizontal_4_dual_neon
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_8_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_8_neon(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
 #define vpx_lpf_horizontal_8 vpx_lpf_horizontal_8_neon
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_8_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_8_dual_neon(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
 #define vpx_lpf_horizontal_8_dual vpx_lpf_horizontal_8_dual_neon
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
+void vpx_lpf_vertical_16_neon(uint8_t* s,
+                              int pitch,
+                              const uint8_t* blimit,
+                              const uint8_t* limit,
+                              const uint8_t* thresh);
 #define vpx_lpf_vertical_16 vpx_lpf_vertical_16_neon
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_vertical_16_dual_neon(uint8_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh);
 #define vpx_lpf_vertical_16_dual vpx_lpf_vertical_16_dual_neon
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_4_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_4_neon(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_vertical_4 vpx_lpf_vertical_4_neon
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_4_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_4_dual_neon(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
 #define vpx_lpf_vertical_4_dual vpx_lpf_vertical_4_dual_neon
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_8_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_8_neon(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_vertical_8 vpx_lpf_vertical_8_neon
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_8_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_8_dual_neon(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
 #define vpx_lpf_vertical_8_dual vpx_lpf_vertical_8_dual_neon
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_across_ip_neon(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
+void vpx_mbpost_proc_across_ip_neon(unsigned char* dst,
+                                    int pitch,
+                                    int rows,
+                                    int cols,
+                                    int flimit);
 #define vpx_mbpost_proc_across_ip vpx_mbpost_proc_across_ip_neon
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_down_neon(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
+void vpx_mbpost_proc_down_neon(unsigned char* dst,
+                               int pitch,
+                               int rows,
+                               int cols,
+                               int flimit);
 #define vpx_mbpost_proc_down vpx_mbpost_proc_down_neon
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-void vpx_minmax_8x8_neon(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
+void vpx_minmax_8x8_neon(const uint8_t* s,
+                         int p,
+                         const uint8_t* d,
+                         int dp,
+                         int* min,
+                         int* max);
 #define vpx_minmax_8x8 vpx_minmax_8x8_neon
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_neon(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
+unsigned int vpx_mse16x16_neon(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
 #define vpx_mse16x16 vpx_mse16x16_neon
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse16x8 vpx_mse16x8_c
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse8x16 vpx_mse8x16_c
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
 #define vpx_mse8x8 vpx_mse8x8_c
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
 #define vpx_plane_add_noise vpx_plane_add_noise_c
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-void vpx_post_proc_down_and_across_mb_row_neon(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-#define vpx_post_proc_down_and_across_mb_row vpx_post_proc_down_and_across_mb_row_neon
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+void vpx_post_proc_down_and_across_mb_row_neon(unsigned char* src,
+                                               unsigned char* dst,
+                                               int src_pitch,
+                                               int dst_pitch,
+                                               int cols,
+                                               unsigned char* flimits,
+                                               int size);
+#define vpx_post_proc_down_and_across_mb_row \
+  vpx_post_proc_down_and_across_mb_row_neon
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-#define vpx_quantize_b vpx_quantize_b_c
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
+void vpx_quantize_b_neon(const tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* zbin_ptr,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         const int16_t* quant_shift_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+#define vpx_quantize_b vpx_quantize_b_neon
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vpx_quantize_b_32x32 vpx_quantize_b_32x32_c
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x16_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad16x16 vpx_sad16x16_neon
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x16_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad16x16_avg vpx_sad16x16_avg_neon
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x3 vpx_sad16x16x3_c
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x16x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad16x16x4d vpx_sad16x16x4d_neon
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x8 vpx_sad16x16x8_c
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad16x32 vpx_sad16x32_neon
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad16x32_avg vpx_sad16x32_avg_neon
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad16x32x4d vpx_sad16x32x4d_neon
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad16x8_neon(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
 #define vpx_sad16x8 vpx_sad16x8_neon
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad16x8_avg_neon(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
 #define vpx_sad16x8_avg vpx_sad16x8_avg_neon
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x3 vpx_sad16x8x3_c
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x8x4d_neon(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
 #define vpx_sad16x8x4d vpx_sad16x8x4d_neon
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x8 vpx_sad16x8x8_c
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x16_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad32x16 vpx_sad32x16_neon
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad32x16_avg vpx_sad32x16_avg_neon
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x16x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x16x4d vpx_sad32x16x4d_neon
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad32x32 vpx_sad32x32_neon
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad32x32_avg vpx_sad32x32_avg_neon
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x32x4d vpx_sad32x32x4d_neon
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x64_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad32x64 vpx_sad32x64_neon
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad32x64_avg vpx_sad32x64_avg_neon
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x64x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x64x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x64x4d vpx_sad32x64x4d_neon
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x4_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x4_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad4x4 vpx_sad4x4_neon
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x4_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x4_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad4x4_avg vpx_sad4x4_avg_neon
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x3 vpx_sad4x4x3_c
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x4x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad4x4x4d vpx_sad4x4x4d_neon
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x8 vpx_sad4x4x8_c
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x8_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad4x8 vpx_sad4x8_neon
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x8_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad4x8_avg vpx_sad4x8_avg_neon
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x8x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad4x8x4d vpx_sad4x8x4d_neon
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad64x32 vpx_sad64x32_neon
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad64x32_avg vpx_sad64x32_avg_neon
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad64x32x4d vpx_sad64x32x4d_neon
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x64_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad64x64 vpx_sad64x64_neon
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad64x64_avg vpx_sad64x64_avg_neon
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x64x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad64x64x4d vpx_sad64x64x4d_neon
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad8x16_neon(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
 #define vpx_sad8x16 vpx_sad8x16_neon
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad8x16_avg_neon(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
 #define vpx_sad8x16_avg vpx_sad8x16_avg_neon
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x3 vpx_sad8x16x3_c
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad8x16x4d_neon(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
 #define vpx_sad8x16x4d vpx_sad8x16x4d_neon
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x8 vpx_sad8x16x8_c
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x4_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x4_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad8x4 vpx_sad8x4_neon
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x4_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x4_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad8x4_avg vpx_sad8x4_avg_neon
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x4x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x4x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad8x4x4d vpx_sad8x4x4d_neon
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x8_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad8x8 vpx_sad8x8_neon
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x8_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad8x8_avg vpx_sad8x8_avg_neon
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x3 vpx_sad8x8x3_c
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x8x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad8x8x4d vpx_sad8x8x4d_neon
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x8 vpx_sad8x8x8_c
 
-int vpx_satd_c(const int16_t *coeff, int length);
-int vpx_satd_neon(const int16_t *coeff, int length);
+int vpx_satd_c(const int16_t* coeff, int length);
+int vpx_satd_neon(const int16_t* coeff, int length);
 #define vpx_satd vpx_satd_neon
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_scaled_2d vpx_scaled_2d_c
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x16 vpx_sub_pixel_avg_variance16x16_neon
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x32 vpx_sub_pixel_avg_variance16x32_neon
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_neon(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x8 vpx_sub_pixel_avg_variance16x8_neon
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x16 vpx_sub_pixel_avg_variance32x16_neon
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x32 vpx_sub_pixel_avg_variance32x32_neon
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x64 vpx_sub_pixel_avg_variance32x64_neon
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x4 vpx_sub_pixel_avg_variance4x4_neon
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x8 vpx_sub_pixel_avg_variance4x8_neon
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x32 vpx_sub_pixel_avg_variance64x32_neon
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x64 vpx_sub_pixel_avg_variance64x64_neon
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_neon(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x16 vpx_sub_pixel_avg_variance8x16_neon
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x4 vpx_sub_pixel_avg_variance8x4_neon
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x8 vpx_sub_pixel_avg_variance8x8_neon
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance16x16 vpx_sub_pixel_variance16x16_neon
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance16x32 vpx_sub_pixel_variance16x32_neon
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_neon(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
 #define vpx_sub_pixel_variance16x8 vpx_sub_pixel_variance16x8_neon
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance32x16 vpx_sub_pixel_variance32x16_neon
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance32x32 vpx_sub_pixel_variance32x32_neon
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance32x64 vpx_sub_pixel_variance32x64_neon
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance4x4 vpx_sub_pixel_variance4x4_neon
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance4x8 vpx_sub_pixel_variance4x8_neon
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance64x32 vpx_sub_pixel_variance64x32_neon
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance64x64 vpx_sub_pixel_variance64x64_neon
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_neon(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
 #define vpx_sub_pixel_variance8x16 vpx_sub_pixel_variance8x16_neon
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance8x4 vpx_sub_pixel_variance8x4_neon
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance8x8 vpx_sub_pixel_variance8x8_neon
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-void vpx_subtract_block_neon(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
+void vpx_subtract_block_neon(int rows,
+                             int cols,
+                             int16_t* diff_ptr,
+                             ptrdiff_t diff_stride,
+                             const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             const uint8_t* pred_ptr,
+                             ptrdiff_t pred_stride);
 #define vpx_subtract_block vpx_subtract_block_neon
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
 #define vpx_sum_squares_2d_i16 vpx_sum_squares_2d_i16_c
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_16x16_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_tm_predictor_16x16 vpx_tm_predictor_16x16_neon
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_32x32_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_tm_predictor_32x32 vpx_tm_predictor_32x32_neon
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_4x4_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_tm_predictor_4x4 vpx_tm_predictor_4x4_neon
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_8x8_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_tm_predictor_8x8 vpx_tm_predictor_8x8_neon
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_16x16_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_v_predictor_16x16 vpx_v_predictor_16x16_neon
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_32x32_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_v_predictor_32x32 vpx_v_predictor_32x32_neon
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_4x4_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_v_predictor_4x4 vpx_v_predictor_4x4_neon
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_8x8_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_v_predictor_8x8 vpx_v_predictor_8x8_neon
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x16_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance16x16 vpx_variance16x16_neon
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance16x32 vpx_variance16x32_neon
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance16x8_neon(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
 #define vpx_variance16x8 vpx_variance16x8_neon
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x16_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x16 vpx_variance32x16_neon
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x32 vpx_variance32x32_neon
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x64_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x64_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x64 vpx_variance32x64_neon
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x4_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x4_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance4x4 vpx_variance4x4_neon
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x8_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance4x8 vpx_variance4x8_neon
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance64x32 vpx_variance64x32_neon
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x64_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance64x64 vpx_variance64x64_neon
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance8x16_neon(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
 #define vpx_variance8x16 vpx_variance8x16_neon
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x4_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x4_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance8x4 vpx_variance8x4_neon
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x8_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance8x8 vpx_variance8x8_neon
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
-int vpx_vector_var_neon(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
+int vpx_vector_var_neon(const int16_t* ref, const int16_t* src, const int bwl);
 #define vpx_vector_var vpx_vector_var_neon
 
 void vpx_dsp_rtcd(void);
@@ -859,12 +2416,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm-neon/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm-neon/vpx_scale_rtcd.h b/third_party/libvpx/source/config/linux/arm-neon/vpx_scale_rtcd.h
index 515ce27..564cb3b 100644
--- a/third_party/libvpx/source/config/linux/arm-neon/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm-neon/vpx_scale_rtcd.h
@@ -13,43 +13,71 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
@@ -58,12 +86,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm/vp8_rtcd.h b/third_party/libvpx/source/config/linux/arm/vp8_rtcd.h
index 3541d2e..ad38b1c 100644
--- a/third_party/libvpx/source/config/linux/arm/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm/vp8_rtcd.h
@@ -26,142 +26,312 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
 #define vp8_bilinear_predict16x16 vp8_bilinear_predict16x16_c
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict4x4 vp8_bilinear_predict4x4_c
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict8x4 vp8_bilinear_predict8x4_c
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict8x8 vp8_bilinear_predict8x8_c
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
 #define vp8_block_error vp8_block_error_c
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
 #define vp8_copy_mem16x16 vp8_copy_mem16x16_c
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
 #define vp8_copy_mem8x4 vp8_copy_mem8x4_c
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
 #define vp8_copy_mem8x8 vp8_copy_mem8x8_c
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
 #define vp8_dc_only_idct_add vp8_dc_only_idct_add_c
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
 #define vp8_denoiser_filter vp8_denoiser_filter_c
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
 #define vp8_denoiser_filter_uv vp8_denoiser_filter_uv_c
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
 #define vp8_dequant_idct_add vp8_dequant_idct_add_c
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
 #define vp8_dequant_idct_add_uv_block vp8_dequant_idct_add_uv_block_c
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
 #define vp8_dequant_idct_add_y_block vp8_dequant_idct_add_y_block_c
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
 #define vp8_dequantize_b vp8_dequantize_b_c
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
 #define vp8_diamond_search_sad vp8_diamond_search_sad_c
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
 #define vp8_fast_quantize_b vp8_fast_quantize_b_c
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp8_filter_by_weight16x16 vp8_filter_by_weight16x16_c
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight8x8 vp8_filter_by_weight8x8_c
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
 #define vp8_full_search_sad vp8_full_search_sad_c
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
 #define vp8_loop_filter_bh vp8_loop_filter_bh_c
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
 #define vp8_loop_filter_bv vp8_loop_filter_bv_c
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbh vp8_loop_filter_mbh_c
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbv vp8_loop_filter_mbv_c
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
 #define vp8_loop_filter_simple_bh vp8_loop_filter_bhs_c
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
 #define vp8_loop_filter_simple_bv vp8_loop_filter_bvs_c
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbh vp8_loop_filter_simple_horizontal_edge_c
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbv vp8_loop_filter_simple_vertical_edge_c
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
 #define vp8_mbblock_error vp8_mbblock_error_c
 
-int vp8_mbuverror_c(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
 #define vp8_mbuverror vp8_mbuverror_c
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
 #define vp8_refining_search_sad vp8_refining_search_sad_c
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
 #define vp8_regular_quantize_b vp8_regular_quantize_b_c
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
 #define vp8_short_fdct4x4 vp8_short_fdct4x4_c
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
 #define vp8_short_fdct8x4 vp8_short_fdct8x4_c
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
 #define vp8_short_idct4x4llm vp8_short_idct4x4llm_c
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4 vp8_short_inv_walsh4x4_c
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
 #define vp8_short_walsh4x4 vp8_short_walsh4x4_c
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_sixtap_predict16x16 vp8_sixtap_predict16x16_c
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict4x4 vp8_sixtap_predict4x4_c
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict8x4 vp8_sixtap_predict8x4_c
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict8x8 vp8_sixtap_predict8x8_c
 
 void vp8_rtcd(void);
@@ -170,12 +340,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm/vp9_rtcd.h b/third_party/libvpx/source/config/linux/arm/vp9_rtcd.h
index 21a448a..8db7b37f 100644
--- a/third_party/libvpx/source/config/linux/arm/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,58 +30,148 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
 #define vp9_block_error vp9_block_error_c
 
-int64_t vp9_block_error_fp_c(const int16_t *coeff, const int16_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const int16_t* coeff,
+                             const int16_t* dqcoeff,
+                             int block_size);
 #define vp9_block_error_fp vp9_block_error_fp_c
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
 #define vp9_denoiser_filter vp9_denoiser_filter_c
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
 #define vp9_diamond_search_sad vp9_diamond_search_sad_c
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
 #define vp9_fdct8x8_quant vp9_fdct8x8_quant_c
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
 #define vp9_fht16x16 vp9_fht16x16_c
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht4x4 vp9_fht4x4_c
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht8x8 vp9_fht8x8_c
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp9_filter_by_weight16x16 vp9_filter_by_weight16x16_c
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp9_filter_by_weight8x8 vp9_filter_by_weight8x8_c
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_fwht4x4 vp9_fwht4x4_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
 #define vp9_iht16x16_256_add vp9_iht16x16_256_add_c
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
 #define vp9_iht4x4_16_add vp9_iht4x4_16_add_c
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
 #define vp9_iht8x8_64_add vp9_iht8x8_64_add_c
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
 #define vp9_quantize_fp vp9_quantize_fp_c
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vp9_quantize_fp_32x32 vp9_quantize_fp_32x32_c
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
 #define vp9_scale_and_extend_frame vp9_scale_and_extend_frame_c
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
 #define vp9_temporal_filter_apply vp9_temporal_filter_apply_c
 
 void vp9_rtcd(void);
@@ -90,12 +180,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm/vpx_config.asm

diff --git a/third_party/libvpx/source/config/linux/arm/vpx_config.asm b/third_party/libvpx/source/config/linux/arm/vpx_config.asm
index 701dd45..4e413fe 100644
--- a/third_party/libvpx/source/config/linux/arm/vpx_config.asm
+++ b/third_party/libvpx/source/config/linux/arm/vpx_config.asm
@@ -21,6 +21,7 @@
 .equ HAVE_AVX ,  0
 .equ HAVE_AVX2 ,  0
 .equ HAVE_VSX ,  0
+.equ HAVE_MMI ,  0
 .equ HAVE_VPX_PORTS ,  1
 .equ HAVE_PTHREAD_H ,  1
 .equ HAVE_UNISTD_H ,  0

third_party/libvpx/source/config/linux/arm/vpx_config.h

diff --git a/third_party/libvpx/source/config/linux/arm/vpx_config.h b/third_party/libvpx/source/config/linux/arm/vpx_config.h
index 234efbf..6f74080 100644
--- a/third_party/libvpx/source/config/linux/arm/vpx_config.h
+++ b/third_party/libvpx/source/config/linux/arm/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 0
 #define HAVE_AVX2 0
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/linux/arm/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/linux/arm/vpx_dsp_rtcd.h
index 38baa0a7..9d1cd0cc 100644
--- a/third_party/libvpx/source/config/linux/arm/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm/vpx_dsp_rtcd.h
@@ -14,669 +14,1530 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
 #define vpx_avg_4x4 vpx_avg_4x4_c
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
 #define vpx_avg_8x8 vpx_avg_8x8_c
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
 #define vpx_comp_avg_pred vpx_comp_avg_pred_c
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_convolve8 vpx_convolve8_c
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_convolve8_avg vpx_convolve8_avg_c
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
 #define vpx_convolve8_avg_horiz vpx_convolve8_avg_horiz_c
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
 #define vpx_convolve8_avg_vert vpx_convolve8_avg_vert_c
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_convolve8_horiz vpx_convolve8_horiz_c
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
 #define vpx_convolve8_vert vpx_convolve8_vert_c
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_convolve_avg vpx_convolve_avg_c
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_convolve_copy vpx_convolve_copy_c
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_c
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_c
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_c
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_c
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_16x16 vpx_d153_predictor_16x16_c
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_32x32 vpx_d153_predictor_32x32_c
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_4x4 vpx_d153_predictor_4x4_c
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_8x8 vpx_d153_predictor_8x8_c
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_16x16 vpx_d207_predictor_16x16_c
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_32x32 vpx_d207_predictor_32x32_c
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_4x4 vpx_d207_predictor_4x4_c
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_8x8 vpx_d207_predictor_8x8_c
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d45_predictor_16x16 vpx_d45_predictor_16x16_c
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d45_predictor_32x32 vpx_d45_predictor_32x32_c
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d45_predictor_4x4 vpx_d45_predictor_4x4_c
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d45_predictor_8x8 vpx_d45_predictor_8x8_c
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_16x16 vpx_d63_predictor_16x16_c
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_32x32 vpx_d63_predictor_32x32_c
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_4x4 vpx_d63_predictor_4x4_c
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_8x8 vpx_d63_predictor_8x8_c
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_128_predictor_16x16 vpx_dc_128_predictor_16x16_c
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_128_predictor_32x32 vpx_dc_128_predictor_32x32_c
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_128_predictor_4x4 vpx_dc_128_predictor_4x4_c
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_128_predictor_8x8 vpx_dc_128_predictor_8x8_c
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_left_predictor_16x16 vpx_dc_left_predictor_16x16_c
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_left_predictor_32x32 vpx_dc_left_predictor_32x32_c
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_left_predictor_4x4 vpx_dc_left_predictor_4x4_c
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_left_predictor_8x8 vpx_dc_left_predictor_8x8_c
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_dc_predictor_16x16 vpx_dc_predictor_16x16_c
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_dc_predictor_32x32 vpx_dc_predictor_32x32_c
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_dc_predictor_4x4 vpx_dc_predictor_4x4_c
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_dc_predictor_8x8 vpx_dc_predictor_8x8_c
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_top_predictor_16x16 vpx_dc_top_predictor_16x16_c
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_top_predictor_32x32 vpx_dc_top_predictor_32x32_c
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_top_predictor_4x4 vpx_dc_top_predictor_4x4_c
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_top_predictor_8x8 vpx_dc_top_predictor_8x8_c
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16 vpx_fdct16x16_c
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16_1 vpx_fdct16x16_1_c
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32 vpx_fdct32x32_c
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_1 vpx_fdct32x32_1_c
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_rd vpx_fdct32x32_rd_c
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4 vpx_fdct4x4_c
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4_1 vpx_fdct4x4_1_c
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8 vpx_fdct8x8_c
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8_1 vpx_fdct8x8_1_c
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
 #define vpx_get16x16var vpx_get16x16var_c
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_c
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
 #define vpx_get8x8var vpx_get8x8var_c
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
 #define vpx_get_mb_ss vpx_get_mb_ss_c
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_h_predictor_16x16 vpx_h_predictor_16x16_c
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_h_predictor_32x32 vpx_h_predictor_32x32_c
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_h_predictor_4x4 vpx_h_predictor_4x4_c
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_h_predictor_8x8 vpx_h_predictor_8x8_c
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          int16_t* coeff);
 #define vpx_hadamard_16x16 vpx_hadamard_16x16_c
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        int16_t* coeff);
 #define vpx_hadamard_8x8 vpx_hadamard_8x8_c
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_10_add vpx_idct16x16_10_add_c
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_1_add vpx_idct16x16_1_add_c
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct16x16_256_add vpx_idct16x16_256_add_c
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_38_add vpx_idct16x16_38_add_c
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct32x32_1024_add vpx_idct32x32_1024_add_c
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct32x32_135_add vpx_idct32x32_135_add_c
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct32x32_1_add vpx_idct32x32_1_add_c
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct32x32_34_add vpx_idct32x32_34_add_c
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_16_add vpx_idct4x4_16_add_c
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_1_add vpx_idct4x4_1_add_c
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_12_add vpx_idct8x8_12_add_c
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_1_add vpx_idct8x8_1_add_c
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_64_add vpx_idct8x8_64_add_c
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
 #define vpx_int_pro_col vpx_int_pro_col_c
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
 #define vpx_int_pro_row vpx_int_pro_row_c
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_16_add vpx_iwht4x4_16_add_c
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_horizontal_16 vpx_lpf_horizontal_16_c
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
 #define vpx_lpf_horizontal_16_dual vpx_lpf_horizontal_16_dual_c
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
 #define vpx_lpf_horizontal_4 vpx_lpf_horizontal_4_c
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
 #define vpx_lpf_horizontal_4_dual vpx_lpf_horizontal_4_dual_c
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
 #define vpx_lpf_horizontal_8 vpx_lpf_horizontal_8_c
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
 #define vpx_lpf_horizontal_8_dual vpx_lpf_horizontal_8_dual_c
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
 #define vpx_lpf_vertical_16 vpx_lpf_vertical_16_c
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
 #define vpx_lpf_vertical_16_dual vpx_lpf_vertical_16_dual_c
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
 #define vpx_lpf_vertical_4 vpx_lpf_vertical_4_c
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
 #define vpx_lpf_vertical_4_dual vpx_lpf_vertical_4_dual_c
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
 #define vpx_lpf_vertical_8 vpx_lpf_vertical_8_c
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
 #define vpx_lpf_vertical_8_dual vpx_lpf_vertical_8_dual_c
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
 #define vpx_mbpost_proc_across_ip vpx_mbpost_proc_across_ip_c
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
 #define vpx_mbpost_proc_down vpx_mbpost_proc_down_c
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
 #define vpx_minmax_8x8 vpx_minmax_8x8_c
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
 #define vpx_mse16x16 vpx_mse16x16_c
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse16x8 vpx_mse16x8_c
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse8x16 vpx_mse8x16_c
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
 #define vpx_mse8x8 vpx_mse8x8_c
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
 #define vpx_plane_add_noise vpx_plane_add_noise_c
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-#define vpx_post_proc_down_and_across_mb_row vpx_post_proc_down_and_across_mb_row_c
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+#define vpx_post_proc_down_and_across_mb_row \
+  vpx_post_proc_down_and_across_mb_row_c
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
 #define vpx_quantize_b vpx_quantize_b_c
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vpx_quantize_b_32x32 vpx_quantize_b_32x32_c
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad16x16 vpx_sad16x16_c
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad16x16_avg vpx_sad16x16_avg_c
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x3 vpx_sad16x16x3_c
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad16x16x4d vpx_sad16x16x4d_c
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x8 vpx_sad16x16x8_c
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad16x32 vpx_sad16x32_c
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad16x32_avg vpx_sad16x32_avg_c
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad16x32x4d vpx_sad16x32x4d_c
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
 #define vpx_sad16x8 vpx_sad16x8_c
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
 #define vpx_sad16x8_avg vpx_sad16x8_avg_c
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x3 vpx_sad16x8x3_c
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x8x4d vpx_sad16x8x4d_c
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x8 vpx_sad16x8x8_c
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x16 vpx_sad32x16_c
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x16_avg vpx_sad32x16_avg_c
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x16x4d vpx_sad32x16x4d_c
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x32 vpx_sad32x32_c
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x32_avg vpx_sad32x32_avg_c
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x32x4d vpx_sad32x32x4d_c
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x64 vpx_sad32x64_c
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x64_avg vpx_sad32x64_avg_c
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x64x4d vpx_sad32x64x4d_c
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad4x4 vpx_sad4x4_c
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad4x4_avg vpx_sad4x4_avg_c
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x3 vpx_sad4x4x3_c
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad4x4x4d vpx_sad4x4x4d_c
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x8 vpx_sad4x4x8_c
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad4x8 vpx_sad4x8_c
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad4x8_avg vpx_sad4x8_avg_c
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad4x8x4d vpx_sad4x8x4d_c
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad64x32 vpx_sad64x32_c
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad64x32_avg vpx_sad64x32_avg_c
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad64x32x4d vpx_sad64x32x4d_c
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad64x64 vpx_sad64x64_c
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad64x64_avg vpx_sad64x64_avg_c
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad64x64x4d vpx_sad64x64x4d_c
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
 #define vpx_sad8x16 vpx_sad8x16_c
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
 #define vpx_sad8x16_avg vpx_sad8x16_avg_c
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x3 vpx_sad8x16x3_c
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad8x16x4d vpx_sad8x16x4d_c
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x8 vpx_sad8x16x8_c
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad8x4 vpx_sad8x4_c
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad8x4_avg vpx_sad8x4_avg_c
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x4x4d vpx_sad8x4x4d_c
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad8x8 vpx_sad8x8_c
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad8x8_avg vpx_sad8x8_avg_c
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x3 vpx_sad8x8x3_c
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x8x4d vpx_sad8x8x4d_c
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x8 vpx_sad8x8x8_c
 
-int vpx_satd_c(const int16_t *coeff, int length);
+int vpx_satd_c(const int16_t* coeff, int length);
 #define vpx_satd vpx_satd_c
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_scaled_2d vpx_scaled_2d_c
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x16 vpx_sub_pixel_avg_variance16x16_c
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x32 vpx_sub_pixel_avg_variance16x32_c
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x8 vpx_sub_pixel_avg_variance16x8_c
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x16 vpx_sub_pixel_avg_variance32x16_c
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x32 vpx_sub_pixel_avg_variance32x32_c
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x64 vpx_sub_pixel_avg_variance32x64_c
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x4 vpx_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x8 vpx_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x32 vpx_sub_pixel_avg_variance64x32_c
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x64 vpx_sub_pixel_avg_variance64x64_c
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x16 vpx_sub_pixel_avg_variance8x16_c
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x4 vpx_sub_pixel_avg_variance8x4_c
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x8 vpx_sub_pixel_avg_variance8x8_c
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance16x16 vpx_sub_pixel_variance16x16_c
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance16x32 vpx_sub_pixel_variance16x32_c
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
 #define vpx_sub_pixel_variance16x8 vpx_sub_pixel_variance16x8_c
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x16 vpx_sub_pixel_variance32x16_c
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x32 vpx_sub_pixel_variance32x32_c
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x64 vpx_sub_pixel_variance32x64_c
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance4x4 vpx_sub_pixel_variance4x4_c
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance4x8 vpx_sub_pixel_variance4x8_c
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance64x32 vpx_sub_pixel_variance64x32_c
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance64x64 vpx_sub_pixel_variance64x64_c
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
 #define vpx_sub_pixel_variance8x16 vpx_sub_pixel_variance8x16_c
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance8x4 vpx_sub_pixel_variance8x4_c
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance8x8 vpx_sub_pixel_variance8x8_c
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
 #define vpx_subtract_block vpx_subtract_block_c
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
 #define vpx_sum_squares_2d_i16 vpx_sum_squares_2d_i16_c
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_tm_predictor_16x16 vpx_tm_predictor_16x16_c
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_tm_predictor_32x32 vpx_tm_predictor_32x32_c
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_tm_predictor_4x4 vpx_tm_predictor_4x4_c
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_tm_predictor_8x8 vpx_tm_predictor_8x8_c
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_v_predictor_16x16 vpx_v_predictor_16x16_c
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_v_predictor_32x32 vpx_v_predictor_32x32_c
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_v_predictor_4x4 vpx_v_predictor_4x4_c
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_v_predictor_8x8 vpx_v_predictor_8x8_c
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance16x16 vpx_variance16x16_c
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance16x32 vpx_variance16x32_c
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
 #define vpx_variance16x8 vpx_variance16x8_c
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x16 vpx_variance32x16_c
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x32 vpx_variance32x32_c
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x64 vpx_variance32x64_c
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance4x4 vpx_variance4x4_c
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance4x8 vpx_variance4x8_c
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance64x32 vpx_variance64x32_c
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance64x64 vpx_variance64x64_c
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
 #define vpx_variance8x16 vpx_variance8x16_c
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance8x4 vpx_variance8x4_c
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance8x8 vpx_variance8x8_c
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
 #define vpx_vector_var vpx_vector_var_c
 
 void vpx_dsp_rtcd(void);
@@ -685,12 +1546,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm/vpx_scale_rtcd.h b/third_party/libvpx/source/config/linux/arm/vpx_scale_rtcd.h
index 515ce27..564cb3b 100644
--- a/third_party/libvpx/source/config/linux/arm/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm/vpx_scale_rtcd.h
@@ -13,43 +13,71 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
@@ -58,12 +86,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm64/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm64/vp8_rtcd.h b/third_party/libvpx/source/config/linux/arm64/vp8_rtcd.h
index 6a7f92c..c6222d0 100644
--- a/third_party/libvpx/source/config/linux/arm64/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm64/vp8_rtcd.h
@@ -26,174 +26,455 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+void vp8_bilinear_predict16x16_neon(unsigned char* src,
+                                    int src_pitch,
+                                    int xofst,
+                                    int yofst,
+                                    unsigned char* dst,
+                                    int dst_pitch);
 #define vp8_bilinear_predict16x16 vp8_bilinear_predict16x16_neon
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict4x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict4x4_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_bilinear_predict4x4 vp8_bilinear_predict4x4_neon
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x4_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_bilinear_predict8x4 vp8_bilinear_predict8x4_neon
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x8_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_bilinear_predict8x8 vp8_bilinear_predict8x8_neon
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
 #define vp8_block_error vp8_block_error_c
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem16x16_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+void vp8_copy_mem16x16_neon(unsigned char* src,
+                            int src_pitch,
+                            unsigned char* dst,
+                            int dst_pitch);
 #define vp8_copy_mem16x16 vp8_copy_mem16x16_neon
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x4_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x4_neon(unsigned char* src,
+                          int src_pitch,
+                          unsigned char* dst,
+                          int dst_pitch);
 #define vp8_copy_mem8x4 vp8_copy_mem8x4_neon
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x8_neon(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x8_neon(unsigned char* src,
+                          int src_pitch,
+                          unsigned char* dst,
+                          int dst_pitch);
 #define vp8_copy_mem8x8 vp8_copy_mem8x8_neon
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-void vp8_dc_only_idct_add_neon(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_dc_only_idct_add_neon(short input,
+                               unsigned char* pred,
+                               int pred_stride,
+                               unsigned char* dst,
+                               int dst_stride);
 #define vp8_dc_only_idct_add vp8_dc_only_idct_add_neon
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_neon(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
+int vp8_denoiser_filter_neon(unsigned char* mc_running_avg_y,
+                             int mc_avg_y_stride,
+                             unsigned char* running_avg_y,
+                             int avg_y_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
 #define vp8_denoiser_filter vp8_denoiser_filter_neon
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_uv_neon(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+int vp8_denoiser_filter_uv_neon(unsigned char* mc_running_avg,
+                                int mc_avg_stride,
+                                unsigned char* running_avg,
+                                int avg_stride,
+                                unsigned char* sig,
+                                int sig_stride,
+                                unsigned int motion_magnitude,
+                                int increase_denoising);
 #define vp8_denoiser_filter_uv vp8_denoiser_filter_uv_neon
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
-void vp8_dequant_idct_add_neon(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
+void vp8_dequant_idct_add_neon(short* input,
+                               short* dq,
+                               unsigned char* output,
+                               int stride);
 #define vp8_dequant_idct_add vp8_dequant_idct_add_neon
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-void vp8_dequant_idct_add_uv_block_neon(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
+void vp8_dequant_idct_add_uv_block_neon(short* q,
+                                        short* dq,
+                                        unsigned char* dst_u,
+                                        unsigned char* dst_v,
+                                        int stride,
+                                        char* eobs);
 #define vp8_dequant_idct_add_uv_block vp8_dequant_idct_add_uv_block_neon
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-void vp8_dequant_idct_add_y_block_neon(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
+void vp8_dequant_idct_add_y_block_neon(short* q,
+                                       short* dq,
+                                       unsigned char* dst,
+                                       int stride,
+                                       char* eobs);
 #define vp8_dequant_idct_add_y_block vp8_dequant_idct_add_y_block_neon
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
-void vp8_dequantize_b_neon(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
+void vp8_dequantize_b_neon(struct blockd*, short* dqc);
 #define vp8_dequantize_b vp8_dequantize_b_neon
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
 #define vp8_diamond_search_sad vp8_diamond_search_sad_c
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
-void vp8_fast_quantize_b_neon(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
+void vp8_fast_quantize_b_neon(struct block*, struct blockd*);
 #define vp8_fast_quantize_b vp8_fast_quantize_b_neon
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp8_filter_by_weight16x16 vp8_filter_by_weight16x16_c
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight8x8 vp8_filter_by_weight8x8_c
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
 #define vp8_full_search_sad vp8_full_search_sad_c
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bh_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bh_neon(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
 #define vp8_loop_filter_bh vp8_loop_filter_bh_neon
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bv_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bv_neon(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
 #define vp8_loop_filter_bv vp8_loop_filter_bv_neon
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbh_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbh_neon(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbh vp8_loop_filter_mbh_neon
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbv_neon(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbv_neon(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbv vp8_loop_filter_mbv_neon
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bhs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bhs_neon(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_bh vp8_loop_filter_bhs_neon
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bvs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bvs_neon(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_bv vp8_loop_filter_bvs_neon
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_mbhs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
+void vp8_loop_filter_mbhs_neon(unsigned char* y,
+                               int ystride,
+                               const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbh vp8_loop_filter_mbhs_neon
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_mbvs_neon(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
+void vp8_loop_filter_mbvs_neon(unsigned char* y,
+                               int ystride,
+                               const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbv vp8_loop_filter_mbvs_neon
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
 #define vp8_mbblock_error vp8_mbblock_error_c
 
-int vp8_mbuverror_c(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
 #define vp8_mbuverror vp8_mbuverror_c
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
 #define vp8_refining_search_sad vp8_refining_search_sad_c
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
 #define vp8_regular_quantize_b vp8_regular_quantize_b_c
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct4x4_neon(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct4x4_neon(short* input, short* output, int pitch);
 #define vp8_short_fdct4x4 vp8_short_fdct4x4_neon
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct8x4_neon(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct8x4_neon(short* input, short* output, int pitch);
 #define vp8_short_fdct8x4 vp8_short_fdct8x4_neon
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-void vp8_short_idct4x4llm_neon(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_short_idct4x4llm_neon(short* input,
+                               unsigned char* pred,
+                               int pitch,
+                               unsigned char* dst,
+                               int dst_stride);
 #define vp8_short_idct4x4llm vp8_short_idct4x4llm_neon
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
-void vp8_short_inv_walsh4x4_neon(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
+void vp8_short_inv_walsh4x4_neon(short* input, short* output);
 #define vp8_short_inv_walsh4x4 vp8_short_inv_walsh4x4_neon
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
-void vp8_short_walsh4x4_neon(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
+void vp8_short_walsh4x4_neon(short* input, short* output, int pitch);
 #define vp8_short_walsh4x4 vp8_short_walsh4x4_neon
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict16x16_neon(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
 #define vp8_sixtap_predict16x16 vp8_sixtap_predict16x16_neon
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict4x4_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
 #define vp8_sixtap_predict4x4 vp8_sixtap_predict4x4_neon
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x4_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
 #define vp8_sixtap_predict8x4 vp8_sixtap_predict8x4_neon
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_neon(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x8_neon(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
 #define vp8_sixtap_predict8x8 vp8_sixtap_predict8x8_neon
 
 void vp8_rtcd(void);
@@ -202,12 +483,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm64/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm64/vp9_rtcd.h b/third_party/libvpx/source/config/linux/arm64/vp9_rtcd.h
index a0f86ea..2ff413b 100644
--- a/third_party/libvpx/source/config/linux/arm64/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm64/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,64 +30,192 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
 #define vp9_block_error vp9_block_error_c
 
-int64_t vp9_block_error_fp_c(const int16_t *coeff, const int16_t *dqcoeff, int block_size);
-int64_t vp9_block_error_fp_neon(const int16_t *coeff, const int16_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const int16_t* coeff,
+                             const int16_t* dqcoeff,
+                             int block_size);
+int64_t vp9_block_error_fp_neon(const int16_t* coeff,
+                                const int16_t* dqcoeff,
+                                int block_size);
 #define vp9_block_error_fp vp9_block_error_fp_neon
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-int vp9_denoiser_filter_neon(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
+int vp9_denoiser_filter_neon(const uint8_t* sig,
+                             int sig_stride,
+                             const uint8_t* mc_avg,
+                             int mc_avg_stride,
+                             uint8_t* avg,
+                             int avg_stride,
+                             int increase_denoising,
+                             BLOCK_SIZE bs,
+                             int motion_magnitude);
 #define vp9_denoiser_filter vp9_denoiser_filter_neon
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
 #define vp9_diamond_search_sad vp9_diamond_search_sad_c
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_fdct8x8_quant_neon(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+void vp9_fdct8x8_quant_neon(const int16_t* input,
+                            int stride,
+                            tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vp9_fdct8x8_quant vp9_fdct8x8_quant_neon
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
 #define vp9_fht16x16 vp9_fht16x16_c
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht4x4 vp9_fht4x4_c
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht8x8 vp9_fht8x8_c
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp9_filter_by_weight16x16 vp9_filter_by_weight16x16_c
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp9_filter_by_weight8x8 vp9_filter_by_weight8x8_c
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_fwht4x4 vp9_fwht4x4_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
 #define vp9_iht16x16_256_add vp9_iht16x16_256_add_c
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht4x4_16_add_neon(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht4x4_16_add_neon(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
 #define vp9_iht4x4_16_add vp9_iht4x4_16_add_neon
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht8x8_64_add_neon(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht8x8_64_add_neon(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
 #define vp9_iht8x8_64_add vp9_iht8x8_64_add_neon
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_neon(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
+void vp9_quantize_fp_neon(const tran_low_t* coeff_ptr,
+                          intptr_t n_coeffs,
+                          int skip_block,
+                          const int16_t* round_ptr,
+                          const int16_t* quant_ptr,
+                          tran_low_t* qcoeff_ptr,
+                          tran_low_t* dqcoeff_ptr,
+                          const int16_t* dequant_ptr,
+                          uint16_t* eob_ptr,
+                          const int16_t* scan,
+                          const int16_t* iscan);
 #define vp9_quantize_fp vp9_quantize_fp_neon
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vp9_quantize_fp_32x32 vp9_quantize_fp_32x32_c
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
 #define vp9_scale_and_extend_frame vp9_scale_and_extend_frame_c
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
 #define vp9_temporal_filter_apply vp9_temporal_filter_apply_c
 
 void vp9_rtcd(void);
@@ -96,12 +224,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm64/vpx_config.asm

diff --git a/third_party/libvpx/source/config/linux/arm64/vpx_config.asm b/third_party/libvpx/source/config/linux/arm64/vpx_config.asm
index 060b6035..fe30a9e6 100644
--- a/third_party/libvpx/source/config/linux/arm64/vpx_config.asm
+++ b/third_party/libvpx/source/config/linux/arm64/vpx_config.asm
@@ -21,6 +21,7 @@
 .equ HAVE_AVX ,  0
 .equ HAVE_AVX2 ,  0
 .equ HAVE_VSX ,  0
+.equ HAVE_MMI ,  0
 .equ HAVE_VPX_PORTS ,  1
 .equ HAVE_PTHREAD_H ,  1
 .equ HAVE_UNISTD_H ,  0

third_party/libvpx/source/config/linux/arm64/vpx_config.h

diff --git a/third_party/libvpx/source/config/linux/arm64/vpx_config.h b/third_party/libvpx/source/config/linux/arm64/vpx_config.h
index a3db07d..49da03e 100644
--- a/third_party/libvpx/source/config/linux/arm64/vpx_config.h
+++ b/third_party/libvpx/source/config/linux/arm64/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 0
 #define HAVE_AVX2 0
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/linux/arm64/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm64/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/linux/arm64/vpx_dsp_rtcd.h
index c694f53..ae6787f 100644
--- a/third_party/libvpx/source/config/linux/arm64/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm64/vpx_dsp_rtcd.h
@@ -14,843 +14,2400 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
-unsigned int vpx_avg_4x4_neon(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
+unsigned int vpx_avg_4x4_neon(const uint8_t*, int p);
 #define vpx_avg_4x4 vpx_avg_4x4_neon
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
-unsigned int vpx_avg_8x8_neon(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
+unsigned int vpx_avg_8x8_neon(const uint8_t*, int p);
 #define vpx_avg_8x8 vpx_avg_8x8_neon
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-void vpx_comp_avg_pred_neon(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
+void vpx_comp_avg_pred_neon(uint8_t* comp_pred,
+                            const uint8_t* pred,
+                            int width,
+                            int height,
+                            const uint8_t* ref,
+                            int ref_stride);
 #define vpx_comp_avg_pred vpx_comp_avg_pred_neon
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_convolve8_neon(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_convolve8 vpx_convolve8_neon
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avg_neon(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_convolve8_avg vpx_convolve8_avg_neon
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_avg_horiz_neon(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 #define vpx_convolve8_avg_horiz vpx_convolve8_avg_horiz_neon
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_avg_vert_neon(const uint8_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h);
 #define vpx_convolve8_avg_vert vpx_convolve8_avg_vert_neon
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+void vpx_convolve8_horiz_neon(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
 #define vpx_convolve8_horiz vpx_convolve8_horiz_neon
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
+void vpx_convolve8_vert_neon(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
 #define vpx_convolve8_vert vpx_convolve8_vert_neon
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_avg_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve_avg_neon(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_convolve_avg vpx_convolve_avg_neon
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_copy_neon(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve_copy_neon(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_convolve_copy vpx_convolve_copy_neon
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d135_predictor_16x16_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_neon
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d135_predictor_32x32_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_neon
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d135_predictor_4x4_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_neon
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d135_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d135_predictor_8x8_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_neon
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_16x16 vpx_d153_predictor_16x16_c
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_32x32 vpx_d153_predictor_32x32_c
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_4x4 vpx_d153_predictor_4x4_c
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_8x8 vpx_d153_predictor_8x8_c
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_16x16 vpx_d207_predictor_16x16_c
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_32x32 vpx_d207_predictor_32x32_c
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_4x4 vpx_d207_predictor_4x4_c
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_8x8 vpx_d207_predictor_8x8_c
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_16x16_neon(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_d45_predictor_16x16 vpx_d45_predictor_16x16_neon
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_32x32_neon(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_d45_predictor_32x32 vpx_d45_predictor_32x32_neon
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_4x4_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d45_predictor_4x4 vpx_d45_predictor_4x4_neon
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_8x8_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d45_predictor_8x8 vpx_d45_predictor_8x8_neon
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_16x16 vpx_d63_predictor_16x16_c
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_32x32 vpx_d63_predictor_32x32_c
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_4x4 vpx_d63_predictor_4x4_c
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_8x8 vpx_d63_predictor_8x8_c
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_16x16_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_128_predictor_16x16 vpx_dc_128_predictor_16x16_neon
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_32x32_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_128_predictor_32x32 vpx_dc_128_predictor_32x32_neon
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_4x4_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_128_predictor_4x4 vpx_dc_128_predictor_4x4_neon
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_8x8_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_128_predictor_8x8 vpx_dc_128_predictor_8x8_neon
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_16x16_neon(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
 #define vpx_dc_left_predictor_16x16 vpx_dc_left_predictor_16x16_neon
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_32x32_neon(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
 #define vpx_dc_left_predictor_32x32 vpx_dc_left_predictor_32x32_neon
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_4x4_neon(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
 #define vpx_dc_left_predictor_4x4 vpx_dc_left_predictor_4x4_neon
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_8x8_neon(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
 #define vpx_dc_left_predictor_8x8 vpx_dc_left_predictor_8x8_neon
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_16x16_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_predictor_16x16 vpx_dc_predictor_16x16_neon
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_32x32_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_predictor_32x32 vpx_dc_predictor_32x32_neon
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_4x4_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_dc_predictor_4x4 vpx_dc_predictor_4x4_neon
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_8x8_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_dc_predictor_8x8 vpx_dc_predictor_8x8_neon
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_16x16_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_top_predictor_16x16 vpx_dc_top_predictor_16x16_neon
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_32x32_neon(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_top_predictor_32x32 vpx_dc_top_predictor_32x32_neon
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_4x4_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_top_predictor_4x4 vpx_dc_top_predictor_4x4_neon
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_8x8_neon(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_top_predictor_8x8 vpx_dc_top_predictor_8x8_neon
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16 vpx_fdct16x16_neon
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16_1 vpx_fdct16x16_1_neon
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32 vpx_fdct32x32_neon
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_1 vpx_fdct32x32_1_neon
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_rd_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_rd_neon(const int16_t* input,
+                           tran_low_t* output,
+                           int stride);
 #define vpx_fdct32x32_rd vpx_fdct32x32_rd_neon
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4 vpx_fdct4x4_neon
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4_1 vpx_fdct4x4_1_neon
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8 vpx_fdct8x8_neon
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_1_neon(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_1_neon(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8_1 vpx_fdct8x8_1_neon
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
+void vpx_get16x16var_neon(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
 #define vpx_get16x16var vpx_get16x16var_neon
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
-unsigned int vpx_get4x4sse_cs_neon(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
+unsigned int vpx_get4x4sse_cs_neon(const unsigned char* src_ptr,
+                                   int source_stride,
+                                   const unsigned char* ref_ptr,
+                                   int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_neon
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get8x8var_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
+void vpx_get8x8var_neon(const uint8_t* src_ptr,
+                        int source_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        unsigned int* sse,
+                        int* sum);
 #define vpx_get8x8var vpx_get8x8var_neon
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
 #define vpx_get_mb_ss vpx_get_mb_ss_c
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_16x16_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_h_predictor_16x16 vpx_h_predictor_16x16_neon
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_32x32_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_h_predictor_32x32 vpx_h_predictor_32x32_neon
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_4x4_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_h_predictor_4x4 vpx_h_predictor_4x4_neon
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_8x8_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_h_predictor_8x8 vpx_h_predictor_8x8_neon
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
-void vpx_hadamard_16x16_neon(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          int16_t* coeff);
+void vpx_hadamard_16x16_neon(const int16_t* src_diff,
+                             int src_stride,
+                             int16_t* coeff);
 #define vpx_hadamard_16x16 vpx_hadamard_16x16_neon
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
-void vpx_hadamard_8x8_neon(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        int16_t* coeff);
+void vpx_hadamard_8x8_neon(const int16_t* src_diff,
+                           int src_stride,
+                           int16_t* coeff);
 #define vpx_hadamard_8x8 vpx_hadamard_8x8_neon
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_10_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_10_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct16x16_10_add vpx_idct16x16_10_add_neon
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_1_add_neon(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct16x16_1_add vpx_idct16x16_1_add_neon
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_256_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct16x16_256_add_neon(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
 #define vpx_idct16x16_256_add vpx_idct16x16_256_add_neon
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_38_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_38_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct16x16_38_add vpx_idct16x16_38_add_neon
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+void vpx_idct32x32_1024_add_neon(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
 #define vpx_idct32x32_1024_add vpx_idct32x32_1024_add_neon
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_135_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct32x32_135_add_neon(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
 #define vpx_idct32x32_135_add vpx_idct32x32_135_add_neon
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_1_add_neon(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct32x32_1_add vpx_idct32x32_1_add_neon
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_34_add_neon(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct32x32_34_add vpx_idct32x32_34_add_neon
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_16_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_16_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct4x4_16_add vpx_idct4x4_16_add_neon
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_1_add_neon(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_1_add vpx_idct4x4_1_add_neon
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_12_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct8x8_12_add vpx_idct8x8_12_add_neon
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_1_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_1_add_neon(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_1_add vpx_idct8x8_1_add_neon
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_64_add_neon(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_64_add_neon(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct8x8_64_add vpx_idct8x8_64_add_neon
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
-int16_t vpx_int_pro_col_neon(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
+int16_t vpx_int_pro_col_neon(const uint8_t* ref, const int width);
 #define vpx_int_pro_col vpx_int_pro_col_neon
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-void vpx_int_pro_row_neon(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
+void vpx_int_pro_row_neon(int16_t* hbuf,
+                          const uint8_t* ref,
+                          const int ref_stride,
+                          const int height);
 #define vpx_int_pro_row vpx_int_pro_row_neon
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_16_add vpx_iwht4x4_16_add_c
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+void vpx_lpf_horizontal_16_neon(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
 #define vpx_lpf_horizontal_16 vpx_lpf_horizontal_16_neon
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_neon(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
 #define vpx_lpf_horizontal_16_dual vpx_lpf_horizontal_16_dual_neon
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_4_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_4_neon(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
 #define vpx_lpf_horizontal_4 vpx_lpf_horizontal_4_neon
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_4_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_4_dual_neon(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
 #define vpx_lpf_horizontal_4_dual vpx_lpf_horizontal_4_dual_neon
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_8_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_8_neon(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
 #define vpx_lpf_horizontal_8 vpx_lpf_horizontal_8_neon
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_8_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_8_dual_neon(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
 #define vpx_lpf_horizontal_8_dual vpx_lpf_horizontal_8_dual_neon
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
+void vpx_lpf_vertical_16_neon(uint8_t* s,
+                              int pitch,
+                              const uint8_t* blimit,
+                              const uint8_t* limit,
+                              const uint8_t* thresh);
 #define vpx_lpf_vertical_16 vpx_lpf_vertical_16_neon
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_vertical_16_dual_neon(uint8_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh);
 #define vpx_lpf_vertical_16_dual vpx_lpf_vertical_16_dual_neon
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_4_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_4_neon(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_vertical_4 vpx_lpf_vertical_4_neon
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_4_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_4_dual_neon(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
 #define vpx_lpf_vertical_4_dual vpx_lpf_vertical_4_dual_neon
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_8_neon(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_8_neon(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_vertical_8 vpx_lpf_vertical_8_neon
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_8_dual_neon(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_8_dual_neon(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
 #define vpx_lpf_vertical_8_dual vpx_lpf_vertical_8_dual_neon
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_across_ip_neon(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
+void vpx_mbpost_proc_across_ip_neon(unsigned char* dst,
+                                    int pitch,
+                                    int rows,
+                                    int cols,
+                                    int flimit);
 #define vpx_mbpost_proc_across_ip vpx_mbpost_proc_across_ip_neon
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_down_neon(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
+void vpx_mbpost_proc_down_neon(unsigned char* dst,
+                               int pitch,
+                               int rows,
+                               int cols,
+                               int flimit);
 #define vpx_mbpost_proc_down vpx_mbpost_proc_down_neon
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-void vpx_minmax_8x8_neon(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
+void vpx_minmax_8x8_neon(const uint8_t* s,
+                         int p,
+                         const uint8_t* d,
+                         int dp,
+                         int* min,
+                         int* max);
 #define vpx_minmax_8x8 vpx_minmax_8x8_neon
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_neon(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
+unsigned int vpx_mse16x16_neon(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
 #define vpx_mse16x16 vpx_mse16x16_neon
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse16x8 vpx_mse16x8_c
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse8x16 vpx_mse8x16_c
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
 #define vpx_mse8x8 vpx_mse8x8_c
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
 #define vpx_plane_add_noise vpx_plane_add_noise_c
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-void vpx_post_proc_down_and_across_mb_row_neon(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-#define vpx_post_proc_down_and_across_mb_row vpx_post_proc_down_and_across_mb_row_neon
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+void vpx_post_proc_down_and_across_mb_row_neon(unsigned char* src,
+                                               unsigned char* dst,
+                                               int src_pitch,
+                                               int dst_pitch,
+                                               int cols,
+                                               unsigned char* flimits,
+                                               int size);
+#define vpx_post_proc_down_and_across_mb_row \
+  vpx_post_proc_down_and_across_mb_row_neon
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-#define vpx_quantize_b vpx_quantize_b_c
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
+void vpx_quantize_b_neon(const tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* zbin_ptr,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         const int16_t* quant_shift_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+#define vpx_quantize_b vpx_quantize_b_neon
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vpx_quantize_b_32x32 vpx_quantize_b_32x32_c
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x16_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad16x16 vpx_sad16x16_neon
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x16_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad16x16_avg vpx_sad16x16_avg_neon
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x3 vpx_sad16x16x3_c
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x16x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad16x16x4d vpx_sad16x16x4d_neon
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x8 vpx_sad16x16x8_c
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad16x32 vpx_sad16x32_neon
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad16x32_avg vpx_sad16x32_avg_neon
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad16x32x4d vpx_sad16x32x4d_neon
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad16x8_neon(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
 #define vpx_sad16x8 vpx_sad16x8_neon
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad16x8_avg_neon(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
 #define vpx_sad16x8_avg vpx_sad16x8_avg_neon
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x3 vpx_sad16x8x3_c
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x8x4d_neon(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
 #define vpx_sad16x8x4d vpx_sad16x8x4d_neon
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x8 vpx_sad16x8x8_c
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x16_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad32x16 vpx_sad32x16_neon
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad32x16_avg vpx_sad32x16_avg_neon
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x16x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x16x4d vpx_sad32x16x4d_neon
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad32x32 vpx_sad32x32_neon
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad32x32_avg vpx_sad32x32_avg_neon
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x32x4d vpx_sad32x32x4d_neon
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x64_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad32x64 vpx_sad32x64_neon
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad32x64_avg vpx_sad32x64_avg_neon
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x64x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x64x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x64x4d vpx_sad32x64x4d_neon
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x4_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x4_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad4x4 vpx_sad4x4_neon
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x4_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x4_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad4x4_avg vpx_sad4x4_avg_neon
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x3 vpx_sad4x4x3_c
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x4x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad4x4x4d vpx_sad4x4x4d_neon
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x8 vpx_sad4x4x8_c
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x8_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad4x8 vpx_sad4x8_neon
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x8_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad4x8_avg vpx_sad4x8_avg_neon
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x8x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad4x8x4d vpx_sad4x8x4d_neon
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x32_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad64x32 vpx_sad64x32_neon
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad64x32_avg vpx_sad64x32_avg_neon
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x32x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x32x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad64x32x4d vpx_sad64x32x4d_neon
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x64_neon(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad64x64 vpx_sad64x64_neon
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_neon(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad64x64_avg vpx_sad64x64_avg_neon
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x64x4d_neon(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad64x64x4d vpx_sad64x64x4d_neon
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x16_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad8x16_neon(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
 #define vpx_sad8x16 vpx_sad8x16_neon
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x16_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad8x16_avg_neon(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
 #define vpx_sad8x16_avg vpx_sad8x16_avg_neon
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x3 vpx_sad8x16x3_c
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad8x16x4d_neon(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
 #define vpx_sad8x16x4d vpx_sad8x16x4d_neon
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x8 vpx_sad8x16x8_c
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x4_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x4_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad8x4 vpx_sad8x4_neon
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x4_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x4_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad8x4_avg vpx_sad8x4_avg_neon
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x4x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x4x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad8x4x4d vpx_sad8x4x4d_neon
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x8_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x8_neon(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad8x8 vpx_sad8x8_neon
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x8_avg_neon(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x8_avg_neon(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad8x8_avg vpx_sad8x8_avg_neon
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x3 vpx_sad8x8x3_c
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x4d_neon(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x8x4d_neon(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad8x8x4d vpx_sad8x8x4d_neon
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x8 vpx_sad8x8x8_c
 
-int vpx_satd_c(const int16_t *coeff, int length);
-int vpx_satd_neon(const int16_t *coeff, int length);
+int vpx_satd_c(const int16_t* coeff, int length);
+int vpx_satd_neon(const int16_t* coeff, int length);
 #define vpx_satd vpx_satd_neon
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_scaled_2d vpx_scaled_2d_c
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x16 vpx_sub_pixel_avg_variance16x16_neon
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x32 vpx_sub_pixel_avg_variance16x32_neon
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_neon(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x8 vpx_sub_pixel_avg_variance16x8_neon
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x16 vpx_sub_pixel_avg_variance32x16_neon
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x32 vpx_sub_pixel_avg_variance32x32_neon
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x64 vpx_sub_pixel_avg_variance32x64_neon
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x4 vpx_sub_pixel_avg_variance4x4_neon
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x8 vpx_sub_pixel_avg_variance4x8_neon
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x32 vpx_sub_pixel_avg_variance64x32_neon
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_neon(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x64 vpx_sub_pixel_avg_variance64x64_neon
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_neon(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x16 vpx_sub_pixel_avg_variance8x16_neon
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x4 vpx_sub_pixel_avg_variance8x4_neon
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_neon(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x8 vpx_sub_pixel_avg_variance8x8_neon
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance16x16 vpx_sub_pixel_variance16x16_neon
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance16x32 vpx_sub_pixel_variance16x32_neon
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_neon(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
 #define vpx_sub_pixel_variance16x8 vpx_sub_pixel_variance16x8_neon
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance32x16 vpx_sub_pixel_variance32x16_neon
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance32x32 vpx_sub_pixel_variance32x32_neon
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance32x64 vpx_sub_pixel_variance32x64_neon
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance4x4 vpx_sub_pixel_variance4x4_neon
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance4x8 vpx_sub_pixel_variance4x8_neon
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance64x32 vpx_sub_pixel_variance64x32_neon
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_neon(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
 #define vpx_sub_pixel_variance64x64 vpx_sub_pixel_variance64x64_neon
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_neon(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
 #define vpx_sub_pixel_variance8x16 vpx_sub_pixel_variance8x16_neon
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance8x4 vpx_sub_pixel_variance8x4_neon
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_neon(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_neon(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
 #define vpx_sub_pixel_variance8x8 vpx_sub_pixel_variance8x8_neon
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-void vpx_subtract_block_neon(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
+void vpx_subtract_block_neon(int rows,
+                             int cols,
+                             int16_t* diff_ptr,
+                             ptrdiff_t diff_stride,
+                             const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             const uint8_t* pred_ptr,
+                             ptrdiff_t pred_stride);
 #define vpx_subtract_block vpx_subtract_block_neon
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
 #define vpx_sum_squares_2d_i16 vpx_sum_squares_2d_i16_c
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_16x16_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_tm_predictor_16x16 vpx_tm_predictor_16x16_neon
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_32x32_neon(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_tm_predictor_32x32 vpx_tm_predictor_32x32_neon
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_4x4_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_tm_predictor_4x4 vpx_tm_predictor_4x4_neon
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_8x8_neon(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_tm_predictor_8x8 vpx_tm_predictor_8x8_neon
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_16x16_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_16x16_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_v_predictor_16x16 vpx_v_predictor_16x16_neon
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_32x32_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_32x32_neon(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_v_predictor_32x32 vpx_v_predictor_32x32_neon
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_4x4_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_4x4_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_v_predictor_4x4 vpx_v_predictor_4x4_neon
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_8x8_neon(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_8x8_neon(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_v_predictor_8x8 vpx_v_predictor_8x8_neon
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x16_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance16x16 vpx_variance16x16_neon
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance16x32 vpx_variance16x32_neon
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance16x8_neon(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
 #define vpx_variance16x8 vpx_variance16x8_neon
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x16_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x16 vpx_variance32x16_neon
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x32 vpx_variance32x32_neon
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x64_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x64_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x64 vpx_variance32x64_neon
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x4_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x4_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance4x4 vpx_variance4x4_neon
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x8_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance4x8 vpx_variance4x8_neon
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x32_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance64x32 vpx_variance64x32_neon
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x64_neon(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance64x64 vpx_variance64x64_neon
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x16_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance8x16_neon(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
 #define vpx_variance8x16 vpx_variance8x16_neon
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x4_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x4_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance8x4 vpx_variance8x4_neon
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x8_neon(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x8_neon(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance8x8 vpx_variance8x8_neon
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
-int vpx_vector_var_neon(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
+int vpx_vector_var_neon(const int16_t* ref, const int16_t* src, const int bwl);
 #define vpx_vector_var vpx_vector_var_neon
 
 void vpx_dsp_rtcd(void);
@@ -859,12 +2416,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/arm64/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/arm64/vpx_scale_rtcd.h b/third_party/libvpx/source/config/linux/arm64/vpx_scale_rtcd.h
index 515ce27..564cb3b 100644
--- a/third_party/libvpx/source/config/linux/arm64/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/linux/arm64/vpx_scale_rtcd.h
@@ -13,43 +13,71 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
@@ -58,12 +86,10 @@
 
 #ifdef RTCD_C
 #include "vpx_ports/arm.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = arm_cpu_caps();
+static void setup_rtcd_internal(void) {
+  int flags = arm_cpu_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/generic/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/generic/vp8_rtcd.h b/third_party/libvpx/source/config/linux/generic/vp8_rtcd.h
index 650bd323..5af3874 100644
--- a/third_party/libvpx/source/config/linux/generic/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/linux/generic/vp8_rtcd.h
@@ -26,142 +26,312 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
 #define vp8_bilinear_predict16x16 vp8_bilinear_predict16x16_c
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict4x4 vp8_bilinear_predict4x4_c
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict8x4 vp8_bilinear_predict8x4_c
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict8x8 vp8_bilinear_predict8x8_c
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
 #define vp8_block_error vp8_block_error_c
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
 #define vp8_copy_mem16x16 vp8_copy_mem16x16_c
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
 #define vp8_copy_mem8x4 vp8_copy_mem8x4_c
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
 #define vp8_copy_mem8x8 vp8_copy_mem8x8_c
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
 #define vp8_dc_only_idct_add vp8_dc_only_idct_add_c
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
 #define vp8_denoiser_filter vp8_denoiser_filter_c
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
 #define vp8_denoiser_filter_uv vp8_denoiser_filter_uv_c
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
 #define vp8_dequant_idct_add vp8_dequant_idct_add_c
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
 #define vp8_dequant_idct_add_uv_block vp8_dequant_idct_add_uv_block_c
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
 #define vp8_dequant_idct_add_y_block vp8_dequant_idct_add_y_block_c
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
 #define vp8_dequantize_b vp8_dequantize_b_c
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
 #define vp8_diamond_search_sad vp8_diamond_search_sad_c
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
 #define vp8_fast_quantize_b vp8_fast_quantize_b_c
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp8_filter_by_weight16x16 vp8_filter_by_weight16x16_c
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight8x8 vp8_filter_by_weight8x8_c
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
 #define vp8_full_search_sad vp8_full_search_sad_c
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
 #define vp8_loop_filter_bh vp8_loop_filter_bh_c
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
 #define vp8_loop_filter_bv vp8_loop_filter_bv_c
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbh vp8_loop_filter_mbh_c
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbv vp8_loop_filter_mbv_c
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
 #define vp8_loop_filter_simple_bh vp8_loop_filter_bhs_c
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
 #define vp8_loop_filter_simple_bv vp8_loop_filter_bvs_c
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbh vp8_loop_filter_simple_horizontal_edge_c
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbv vp8_loop_filter_simple_vertical_edge_c
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
 #define vp8_mbblock_error vp8_mbblock_error_c
 
-int vp8_mbuverror_c(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
 #define vp8_mbuverror vp8_mbuverror_c
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
 #define vp8_refining_search_sad vp8_refining_search_sad_c
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
 #define vp8_regular_quantize_b vp8_regular_quantize_b_c
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
 #define vp8_short_fdct4x4 vp8_short_fdct4x4_c
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
 #define vp8_short_fdct8x4 vp8_short_fdct8x4_c
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
 #define vp8_short_idct4x4llm vp8_short_idct4x4llm_c
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4 vp8_short_inv_walsh4x4_c
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
 #define vp8_short_walsh4x4 vp8_short_walsh4x4_c
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_sixtap_predict16x16 vp8_sixtap_predict16x16_c
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict4x4 vp8_sixtap_predict4x4_c
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict8x4 vp8_sixtap_predict8x4_c
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict8x8 vp8_sixtap_predict8x8_c
 
 void vp8_rtcd(void);
@@ -169,9 +339,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/linux/generic/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/generic/vp9_rtcd.h b/third_party/libvpx/source/config/linux/generic/vp9_rtcd.h
index a4a5510..ce78cca1 100644
--- a/third_party/libvpx/source/config/linux/generic/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/linux/generic/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,100 +30,258 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
 #define vp9_block_error vp9_block_error_c
 
-int64_t vp9_block_error_fp_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             int block_size);
 #define vp9_block_error_fp vp9_block_error_fp_c
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
 #define vp9_denoiser_filter vp9_denoiser_filter_c
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
 #define vp9_diamond_search_sad vp9_diamond_search_sad_c
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
 #define vp9_fdct8x8_quant vp9_fdct8x8_quant_c
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
 #define vp9_fht16x16 vp9_fht16x16_c
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht4x4 vp9_fht4x4_c
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht8x8 vp9_fht8x8_c
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp9_filter_by_weight16x16 vp9_filter_by_weight16x16_c
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp9_filter_by_weight8x8 vp9_filter_by_weight8x8_c
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_fwht4x4 vp9_fwht4x4_c
 
-int64_t vp9_highbd_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
+int64_t vp9_highbd_block_error_c(const tran_low_t* coeff,
+                                 const tran_low_t* dqcoeff,
+                                 intptr_t block_size,
+                                 int64_t* ssz,
+                                 int bd);
 #define vp9_highbd_block_error vp9_highbd_block_error_c
 
-void vp9_highbd_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht16x16_c(const int16_t* input,
+                           tran_low_t* output,
+                           int stride,
+                           int tx_type);
 #define vp9_highbd_fht16x16 vp9_highbd_fht16x16_c
 
-void vp9_highbd_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht4x4_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht4x4 vp9_highbd_fht4x4_c
 
-void vp9_highbd_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht8x8_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht8x8 vp9_highbd_fht8x8_c
 
-void vp9_highbd_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_highbd_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_highbd_fwht4x4 vp9_highbd_fwht4x4_c
 
-void vp9_highbd_iht16x16_256_add_c(const tran_low_t *input, uint16_t *output, int pitch, int tx_type, int bd);
+void vp9_highbd_iht16x16_256_add_c(const tran_low_t* input,
+                                   uint16_t* output,
+                                   int pitch,
+                                   int tx_type,
+                                   int bd);
 #define vp9_highbd_iht16x16_256_add vp9_highbd_iht16x16_256_add_c
 
-void vp9_highbd_iht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht4x4_16_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht4x4_16_add vp9_highbd_iht4x4_16_add_c
 
-void vp9_highbd_iht8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht8x8_64_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht8x8_64_add vp9_highbd_iht8x8_64_add_c
 
-void vp9_highbd_mbpost_proc_across_ip_c(uint16_t *src, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_across_ip_c(uint16_t* src,
+                                        int pitch,
+                                        int rows,
+                                        int cols,
+                                        int flimit);
 #define vp9_highbd_mbpost_proc_across_ip vp9_highbd_mbpost_proc_across_ip_c
 
-void vp9_highbd_mbpost_proc_down_c(uint16_t *dst, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_down_c(uint16_t* dst,
+                                   int pitch,
+                                   int rows,
+                                   int cols,
+                                   int flimit);
 #define vp9_highbd_mbpost_proc_down vp9_highbd_mbpost_proc_down_c
 
-void vp9_highbd_post_proc_down_and_across_c(const uint16_t *src_ptr, uint16_t *dst_ptr, int src_pixels_per_line, int dst_pixels_per_line, int rows, int cols, int flimit);
-#define vp9_highbd_post_proc_down_and_across vp9_highbd_post_proc_down_and_across_c
+void vp9_highbd_post_proc_down_and_across_c(const uint16_t* src_ptr,
+                                            uint16_t* dst_ptr,
+                                            int src_pixels_per_line,
+                                            int dst_pixels_per_line,
+                                            int rows,
+                                            int cols,
+                                            int flimit);
+#define vp9_highbd_post_proc_down_and_across \
+  vp9_highbd_post_proc_down_and_across_c
 
-void vp9_highbd_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_c(const tran_low_t* coeff_ptr,
+                              intptr_t n_coeffs,
+                              int skip_block,
+                              const int16_t* round_ptr,
+                              const int16_t* quant_ptr,
+                              tran_low_t* qcoeff_ptr,
+                              tran_low_t* dqcoeff_ptr,
+                              const int16_t* dequant_ptr,
+                              uint16_t* eob_ptr,
+                              const int16_t* scan,
+                              const int16_t* iscan);
 #define vp9_highbd_quantize_fp vp9_highbd_quantize_fp_c
 
-void vp9_highbd_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 #define vp9_highbd_quantize_fp_32x32 vp9_highbd_quantize_fp_32x32_c
 
-void vp9_highbd_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_highbd_temporal_filter_apply_c(const uint8_t* frame1,
+                                        unsigned int stride,
+                                        const uint8_t* frame2,
+                                        unsigned int block_width,
+                                        unsigned int block_height,
+                                        int strength,
+                                        int filter_weight,
+                                        uint32_t* accumulator,
+                                        uint16_t* count);
 #define vp9_highbd_temporal_filter_apply vp9_highbd_temporal_filter_apply_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
 #define vp9_iht16x16_256_add vp9_iht16x16_256_add_c
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
 #define vp9_iht4x4_16_add vp9_iht4x4_16_add_c
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
 #define vp9_iht8x8_64_add vp9_iht8x8_64_add_c
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
 #define vp9_quantize_fp vp9_quantize_fp_c
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vp9_quantize_fp_32x32 vp9_quantize_fp_32x32_c
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
 #define vp9_scale_and_extend_frame vp9_scale_and_extend_frame_c
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
 #define vp9_temporal_filter_apply vp9_temporal_filter_apply_c
 
 void vp9_rtcd(void);
@@ -131,9 +289,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/linux/generic/vpx_config.asm

diff --git a/third_party/libvpx/source/config/linux/generic/vpx_config.asm b/third_party/libvpx/source/config/linux/generic/vpx_config.asm
index a1af6955..e9caf6a6 100644
--- a/third_party/libvpx/source/config/linux/generic/vpx_config.asm
+++ b/third_party/libvpx/source/config/linux/generic/vpx_config.asm
@@ -21,6 +21,7 @@
 .equ HAVE_AVX ,  0
 .equ HAVE_AVX2 ,  0
 .equ HAVE_VSX ,  0
+.equ HAVE_MMI ,  0
 .equ HAVE_VPX_PORTS ,  1
 .equ HAVE_PTHREAD_H ,  1
 .equ HAVE_UNISTD_H ,  0

third_party/libvpx/source/config/linux/generic/vpx_config.h

diff --git a/third_party/libvpx/source/config/linux/generic/vpx_config.h b/third_party/libvpx/source/config/linux/generic/vpx_config.h
index be4ac641..2c4574a 100644
--- a/third_party/libvpx/source/config/linux/generic/vpx_config.h
+++ b/third_party/libvpx/source/config/linux/generic/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 0
 #define HAVE_AVX2 0
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/linux/generic/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/generic/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/linux/generic/vpx_dsp_rtcd.h
index e8379173f..114b01b 100644
--- a/third_party/libvpx/source/config/linux/generic/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/linux/generic/vpx_dsp_rtcd.h
@@ -14,1497 +14,3789 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
 #define vpx_avg_4x4 vpx_avg_4x4_c
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
 #define vpx_avg_8x8 vpx_avg_8x8_c
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
 #define vpx_comp_avg_pred vpx_comp_avg_pred_c
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_convolve8 vpx_convolve8_c
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_convolve8_avg vpx_convolve8_avg_c
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
 #define vpx_convolve8_avg_horiz vpx_convolve8_avg_horiz_c
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
 #define vpx_convolve8_avg_vert vpx_convolve8_avg_vert_c
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_convolve8_horiz vpx_convolve8_horiz_c
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
 #define vpx_convolve8_vert vpx_convolve8_vert_c
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_convolve_avg vpx_convolve_avg_c
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_convolve_copy vpx_convolve_copy_c
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_c
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_c
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_c
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_c
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_16x16 vpx_d153_predictor_16x16_c
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_32x32 vpx_d153_predictor_32x32_c
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_4x4 vpx_d153_predictor_4x4_c
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_8x8 vpx_d153_predictor_8x8_c
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_16x16 vpx_d207_predictor_16x16_c
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_32x32 vpx_d207_predictor_32x32_c
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_4x4 vpx_d207_predictor_4x4_c
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_8x8 vpx_d207_predictor_8x8_c
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d45_predictor_16x16 vpx_d45_predictor_16x16_c
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d45_predictor_32x32 vpx_d45_predictor_32x32_c
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d45_predictor_4x4 vpx_d45_predictor_4x4_c
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d45_predictor_8x8 vpx_d45_predictor_8x8_c
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_16x16 vpx_d63_predictor_16x16_c
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_32x32 vpx_d63_predictor_32x32_c
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_4x4 vpx_d63_predictor_4x4_c
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_8x8 vpx_d63_predictor_8x8_c
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_128_predictor_16x16 vpx_dc_128_predictor_16x16_c
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_128_predictor_32x32 vpx_dc_128_predictor_32x32_c
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_128_predictor_4x4 vpx_dc_128_predictor_4x4_c
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_128_predictor_8x8 vpx_dc_128_predictor_8x8_c
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_left_predictor_16x16 vpx_dc_left_predictor_16x16_c
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_left_predictor_32x32 vpx_dc_left_predictor_32x32_c
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_left_predictor_4x4 vpx_dc_left_predictor_4x4_c
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_left_predictor_8x8 vpx_dc_left_predictor_8x8_c
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_dc_predictor_16x16 vpx_dc_predictor_16x16_c
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_dc_predictor_32x32 vpx_dc_predictor_32x32_c
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_dc_predictor_4x4 vpx_dc_predictor_4x4_c
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_dc_predictor_8x8 vpx_dc_predictor_8x8_c
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_top_predictor_16x16 vpx_dc_top_predictor_16x16_c
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_top_predictor_32x32 vpx_dc_top_predictor_32x32_c
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_top_predictor_4x4 vpx_dc_top_predictor_4x4_c
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_top_predictor_8x8 vpx_dc_top_predictor_8x8_c
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16 vpx_fdct16x16_c
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16_1 vpx_fdct16x16_1_c
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32 vpx_fdct32x32_c
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_1 vpx_fdct32x32_1_c
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_rd vpx_fdct32x32_rd_c
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4 vpx_fdct4x4_c
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4_1 vpx_fdct4x4_1_c
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8 vpx_fdct8x8_c
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8_1 vpx_fdct8x8_1_c
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
 #define vpx_get16x16var vpx_get16x16var_c
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_c
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
 #define vpx_get8x8var vpx_get8x8var_c
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
 #define vpx_get_mb_ss vpx_get_mb_ss_c
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_h_predictor_16x16 vpx_h_predictor_16x16_c
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_h_predictor_32x32 vpx_h_predictor_32x32_c
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_h_predictor_4x4 vpx_h_predictor_4x4_c
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_h_predictor_8x8 vpx_h_predictor_8x8_c
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          tran_low_t* coeff);
 #define vpx_hadamard_16x16 vpx_hadamard_16x16_c
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        tran_low_t* coeff);
 #define vpx_hadamard_8x8 vpx_hadamard_8x8_c
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_highbd_10_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_10_get16x16var vpx_highbd_10_get16x16var_c
 
-void vpx_highbd_10_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_10_get8x8var vpx_highbd_10_get8x8var_c
 
-unsigned int vpx_highbd_10_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
 #define vpx_highbd_10_mse16x16 vpx_highbd_10_mse16x16_c
 
-unsigned int vpx_highbd_10_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse16x8 vpx_highbd_10_mse16x8_c
 
-unsigned int vpx_highbd_10_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse8x16 vpx_highbd_10_mse8x16_c
 
-unsigned int vpx_highbd_10_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_10_mse8x8 vpx_highbd_10_mse8x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x16 vpx_highbd_10_sub_pixel_avg_variance16x16_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x16 \
+  vpx_highbd_10_sub_pixel_avg_variance16x16_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x32 vpx_highbd_10_sub_pixel_avg_variance16x32_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x32 \
+  vpx_highbd_10_sub_pixel_avg_variance16x32_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x8 vpx_highbd_10_sub_pixel_avg_variance16x8_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x8 \
+  vpx_highbd_10_sub_pixel_avg_variance16x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x16 vpx_highbd_10_sub_pixel_avg_variance32x16_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x16 \
+  vpx_highbd_10_sub_pixel_avg_variance32x16_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x32 vpx_highbd_10_sub_pixel_avg_variance32x32_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x32 \
+  vpx_highbd_10_sub_pixel_avg_variance32x32_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x64 vpx_highbd_10_sub_pixel_avg_variance32x64_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x64 \
+  vpx_highbd_10_sub_pixel_avg_variance32x64_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x4 vpx_highbd_10_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x4 \
+  vpx_highbd_10_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x8 vpx_highbd_10_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x8 \
+  vpx_highbd_10_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance64x32 vpx_highbd_10_sub_pixel_avg_variance64x32_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance64x32 \
+  vpx_highbd_10_sub_pixel_avg_variance64x32_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance64x64 vpx_highbd_10_sub_pixel_avg_variance64x64_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance64x64 \
+  vpx_highbd_10_sub_pixel_avg_variance64x64_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x16 vpx_highbd_10_sub_pixel_avg_variance8x16_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x16 \
+  vpx_highbd_10_sub_pixel_avg_variance8x16_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x4 vpx_highbd_10_sub_pixel_avg_variance8x4_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x4 \
+  vpx_highbd_10_sub_pixel_avg_variance8x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x8 vpx_highbd_10_sub_pixel_avg_variance8x8_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x8 \
+  vpx_highbd_10_sub_pixel_avg_variance8x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x16 vpx_highbd_10_sub_pixel_variance16x16_c
+uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x16 \
+  vpx_highbd_10_sub_pixel_variance16x16_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x32 vpx_highbd_10_sub_pixel_variance16x32_c
+uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x32 \
+  vpx_highbd_10_sub_pixel_variance16x32_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x8 vpx_highbd_10_sub_pixel_variance16x8_c
+uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x8 \
+  vpx_highbd_10_sub_pixel_variance16x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x16 vpx_highbd_10_sub_pixel_variance32x16_c
+uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x16 \
+  vpx_highbd_10_sub_pixel_variance32x16_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x32 vpx_highbd_10_sub_pixel_variance32x32_c
+uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x32 \
+  vpx_highbd_10_sub_pixel_variance32x32_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x64 vpx_highbd_10_sub_pixel_variance32x64_c
+uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x64 \
+  vpx_highbd_10_sub_pixel_variance32x64_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x4 vpx_highbd_10_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x4 \
+  vpx_highbd_10_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x8 vpx_highbd_10_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x8 \
+  vpx_highbd_10_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance64x32 vpx_highbd_10_sub_pixel_variance64x32_c
+uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance64x32 \
+  vpx_highbd_10_sub_pixel_variance64x32_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance64x64 vpx_highbd_10_sub_pixel_variance64x64_c
+uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance64x64 \
+  vpx_highbd_10_sub_pixel_variance64x64_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x16 vpx_highbd_10_sub_pixel_variance8x16_c
+uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x16 \
+  vpx_highbd_10_sub_pixel_variance8x16_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x4 vpx_highbd_10_sub_pixel_variance8x4_c
+uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x4 \
+  vpx_highbd_10_sub_pixel_variance8x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x8 vpx_highbd_10_sub_pixel_variance8x8_c
+uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x8 \
+  vpx_highbd_10_sub_pixel_variance8x8_c
 
-unsigned int vpx_highbd_10_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_10_variance16x16 vpx_highbd_10_variance16x16_c
 
-unsigned int vpx_highbd_10_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_10_variance16x32 vpx_highbd_10_variance16x32_c
 
-unsigned int vpx_highbd_10_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_10_variance16x8 vpx_highbd_10_variance16x8_c
 
-unsigned int vpx_highbd_10_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_10_variance32x16 vpx_highbd_10_variance32x16_c
 
-unsigned int vpx_highbd_10_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_10_variance32x32 vpx_highbd_10_variance32x32_c
 
-unsigned int vpx_highbd_10_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_10_variance32x64 vpx_highbd_10_variance32x64_c
 
-unsigned int vpx_highbd_10_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x4 vpx_highbd_10_variance4x4_c
 
-unsigned int vpx_highbd_10_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x8 vpx_highbd_10_variance4x8_c
 
-unsigned int vpx_highbd_10_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_10_variance64x32 vpx_highbd_10_variance64x32_c
 
-unsigned int vpx_highbd_10_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_10_variance64x64 vpx_highbd_10_variance64x64_c
 
-unsigned int vpx_highbd_10_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_10_variance8x16 vpx_highbd_10_variance8x16_c
 
-unsigned int vpx_highbd_10_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance8x4 vpx_highbd_10_variance8x4_c
 
-unsigned int vpx_highbd_10_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance8x8 vpx_highbd_10_variance8x8_c
 
-void vpx_highbd_12_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_12_get16x16var vpx_highbd_12_get16x16var_c
 
-void vpx_highbd_12_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_12_get8x8var vpx_highbd_12_get8x8var_c
 
-unsigned int vpx_highbd_12_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
 #define vpx_highbd_12_mse16x16 vpx_highbd_12_mse16x16_c
 
-unsigned int vpx_highbd_12_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse16x8 vpx_highbd_12_mse16x8_c
 
-unsigned int vpx_highbd_12_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse8x16 vpx_highbd_12_mse8x16_c
 
-unsigned int vpx_highbd_12_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_12_mse8x8 vpx_highbd_12_mse8x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x16 vpx_highbd_12_sub_pixel_avg_variance16x16_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x16 \
+  vpx_highbd_12_sub_pixel_avg_variance16x16_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x32 vpx_highbd_12_sub_pixel_avg_variance16x32_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x32 \
+  vpx_highbd_12_sub_pixel_avg_variance16x32_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x8 vpx_highbd_12_sub_pixel_avg_variance16x8_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x8 \
+  vpx_highbd_12_sub_pixel_avg_variance16x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x16 vpx_highbd_12_sub_pixel_avg_variance32x16_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x16 \
+  vpx_highbd_12_sub_pixel_avg_variance32x16_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x32 vpx_highbd_12_sub_pixel_avg_variance32x32_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x32 \
+  vpx_highbd_12_sub_pixel_avg_variance32x32_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x64 vpx_highbd_12_sub_pixel_avg_variance32x64_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x64 \
+  vpx_highbd_12_sub_pixel_avg_variance32x64_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x4 vpx_highbd_12_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x4 \
+  vpx_highbd_12_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x8 vpx_highbd_12_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x8 \
+  vpx_highbd_12_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance64x32 vpx_highbd_12_sub_pixel_avg_variance64x32_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance64x32 \
+  vpx_highbd_12_sub_pixel_avg_variance64x32_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance64x64 vpx_highbd_12_sub_pixel_avg_variance64x64_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance64x64 \
+  vpx_highbd_12_sub_pixel_avg_variance64x64_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x16 vpx_highbd_12_sub_pixel_avg_variance8x16_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x16 \
+  vpx_highbd_12_sub_pixel_avg_variance8x16_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x4 vpx_highbd_12_sub_pixel_avg_variance8x4_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x4 \
+  vpx_highbd_12_sub_pixel_avg_variance8x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x8 vpx_highbd_12_sub_pixel_avg_variance8x8_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x8 \
+  vpx_highbd_12_sub_pixel_avg_variance8x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x16 vpx_highbd_12_sub_pixel_variance16x16_c
+uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x16 \
+  vpx_highbd_12_sub_pixel_variance16x16_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x32 vpx_highbd_12_sub_pixel_variance16x32_c
+uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x32 \
+  vpx_highbd_12_sub_pixel_variance16x32_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x8 vpx_highbd_12_sub_pixel_variance16x8_c
+uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x8 \
+  vpx_highbd_12_sub_pixel_variance16x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x16 vpx_highbd_12_sub_pixel_variance32x16_c
+uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x16 \
+  vpx_highbd_12_sub_pixel_variance32x16_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x32 vpx_highbd_12_sub_pixel_variance32x32_c
+uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x32 \
+  vpx_highbd_12_sub_pixel_variance32x32_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x64 vpx_highbd_12_sub_pixel_variance32x64_c
+uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x64 \
+  vpx_highbd_12_sub_pixel_variance32x64_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x4 vpx_highbd_12_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x4 \
+  vpx_highbd_12_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x8 vpx_highbd_12_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x8 \
+  vpx_highbd_12_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance64x32 vpx_highbd_12_sub_pixel_variance64x32_c
+uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance64x32 \
+  vpx_highbd_12_sub_pixel_variance64x32_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance64x64 vpx_highbd_12_sub_pixel_variance64x64_c
+uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance64x64 \
+  vpx_highbd_12_sub_pixel_variance64x64_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x16 vpx_highbd_12_sub_pixel_variance8x16_c
+uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x16 \
+  vpx_highbd_12_sub_pixel_variance8x16_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x4 vpx_highbd_12_sub_pixel_variance8x4_c
+uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x4 \
+  vpx_highbd_12_sub_pixel_variance8x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x8 vpx_highbd_12_sub_pixel_variance8x8_c
+uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x8 \
+  vpx_highbd_12_sub_pixel_variance8x8_c
 
-unsigned int vpx_highbd_12_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_12_variance16x16 vpx_highbd_12_variance16x16_c
 
-unsigned int vpx_highbd_12_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_12_variance16x32 vpx_highbd_12_variance16x32_c
 
-unsigned int vpx_highbd_12_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_12_variance16x8 vpx_highbd_12_variance16x8_c
 
-unsigned int vpx_highbd_12_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_12_variance32x16 vpx_highbd_12_variance32x16_c
 
-unsigned int vpx_highbd_12_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_12_variance32x32 vpx_highbd_12_variance32x32_c
 
-unsigned int vpx_highbd_12_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_12_variance32x64 vpx_highbd_12_variance32x64_c
 
-unsigned int vpx_highbd_12_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x4 vpx_highbd_12_variance4x4_c
 
-unsigned int vpx_highbd_12_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x8 vpx_highbd_12_variance4x8_c
 
-unsigned int vpx_highbd_12_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_12_variance64x32 vpx_highbd_12_variance64x32_c
 
-unsigned int vpx_highbd_12_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_12_variance64x64 vpx_highbd_12_variance64x64_c
 
-unsigned int vpx_highbd_12_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_12_variance8x16 vpx_highbd_12_variance8x16_c
 
-unsigned int vpx_highbd_12_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance8x4 vpx_highbd_12_variance8x4_c
 
-unsigned int vpx_highbd_12_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance8x8 vpx_highbd_12_variance8x8_c
 
-void vpx_highbd_8_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get16x16var_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse,
+                                int* sum);
 #define vpx_highbd_8_get16x16var vpx_highbd_8_get16x16var_c
 
-void vpx_highbd_8_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get8x8var_c(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              unsigned int* sse,
+                              int* sum);
 #define vpx_highbd_8_get8x8var vpx_highbd_8_get8x8var_c
 
-unsigned int vpx_highbd_8_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_8_mse16x16 vpx_highbd_8_mse16x16_c
 
-unsigned int vpx_highbd_8_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse16x8 vpx_highbd_8_mse16x8_c
 
-unsigned int vpx_highbd_8_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x16_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse8x16 vpx_highbd_8_mse8x16_c
 
-unsigned int vpx_highbd_8_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x8_c(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int recon_stride,
+                                   unsigned int* sse);
 #define vpx_highbd_8_mse8x8 vpx_highbd_8_mse8x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x16 vpx_highbd_8_sub_pixel_avg_variance16x16_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x16 \
+  vpx_highbd_8_sub_pixel_avg_variance16x16_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x32 vpx_highbd_8_sub_pixel_avg_variance16x32_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x32 \
+  vpx_highbd_8_sub_pixel_avg_variance16x32_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x8 vpx_highbd_8_sub_pixel_avg_variance16x8_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x8 \
+  vpx_highbd_8_sub_pixel_avg_variance16x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x16 vpx_highbd_8_sub_pixel_avg_variance32x16_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x16 \
+  vpx_highbd_8_sub_pixel_avg_variance32x16_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x32 vpx_highbd_8_sub_pixel_avg_variance32x32_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x32 \
+  vpx_highbd_8_sub_pixel_avg_variance32x32_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x64 vpx_highbd_8_sub_pixel_avg_variance32x64_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x64 \
+  vpx_highbd_8_sub_pixel_avg_variance32x64_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x4 vpx_highbd_8_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x4 \
+  vpx_highbd_8_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x8 vpx_highbd_8_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x8 \
+  vpx_highbd_8_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance64x32 vpx_highbd_8_sub_pixel_avg_variance64x32_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance64x32 \
+  vpx_highbd_8_sub_pixel_avg_variance64x32_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance64x64 vpx_highbd_8_sub_pixel_avg_variance64x64_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance64x64 \
+  vpx_highbd_8_sub_pixel_avg_variance64x64_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x16 vpx_highbd_8_sub_pixel_avg_variance8x16_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x16 \
+  vpx_highbd_8_sub_pixel_avg_variance8x16_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x4 vpx_highbd_8_sub_pixel_avg_variance8x4_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x4 \
+  vpx_highbd_8_sub_pixel_avg_variance8x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x8 vpx_highbd_8_sub_pixel_avg_variance8x8_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x8 \
+  vpx_highbd_8_sub_pixel_avg_variance8x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x16 vpx_highbd_8_sub_pixel_variance16x16_c
+uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x16 \
+  vpx_highbd_8_sub_pixel_variance16x16_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x32 vpx_highbd_8_sub_pixel_variance16x32_c
+uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x32 \
+  vpx_highbd_8_sub_pixel_variance16x32_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x8 vpx_highbd_8_sub_pixel_variance16x8_c
+uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x8 \
+  vpx_highbd_8_sub_pixel_variance16x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x16 vpx_highbd_8_sub_pixel_variance32x16_c
+uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x16 \
+  vpx_highbd_8_sub_pixel_variance32x16_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x32 vpx_highbd_8_sub_pixel_variance32x32_c
+uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x32 \
+  vpx_highbd_8_sub_pixel_variance32x32_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x64 vpx_highbd_8_sub_pixel_variance32x64_c
+uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x64 \
+  vpx_highbd_8_sub_pixel_variance32x64_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x4 vpx_highbd_8_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x8 vpx_highbd_8_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance64x32 vpx_highbd_8_sub_pixel_variance64x32_c
+uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance64x32 \
+  vpx_highbd_8_sub_pixel_variance64x32_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance64x64 vpx_highbd_8_sub_pixel_variance64x64_c
+uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance64x64 \
+  vpx_highbd_8_sub_pixel_variance64x64_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance8x16 vpx_highbd_8_sub_pixel_variance8x16_c
+uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance8x16 \
+  vpx_highbd_8_sub_pixel_variance8x16_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance8x4 vpx_highbd_8_sub_pixel_variance8x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance8x8 vpx_highbd_8_sub_pixel_variance8x8_c
 
-unsigned int vpx_highbd_8_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_8_variance16x16 vpx_highbd_8_variance16x16_c
 
-unsigned int vpx_highbd_8_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_8_variance16x32 vpx_highbd_8_variance16x32_c
 
-unsigned int vpx_highbd_8_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_8_variance16x8 vpx_highbd_8_variance16x8_c
 
-unsigned int vpx_highbd_8_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_8_variance32x16 vpx_highbd_8_variance32x16_c
 
-unsigned int vpx_highbd_8_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_8_variance32x32 vpx_highbd_8_variance32x32_c
 
-unsigned int vpx_highbd_8_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_8_variance32x64 vpx_highbd_8_variance32x64_c
 
-unsigned int vpx_highbd_8_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x4 vpx_highbd_8_variance4x4_c
 
-unsigned int vpx_highbd_8_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x8 vpx_highbd_8_variance4x8_c
 
-unsigned int vpx_highbd_8_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_8_variance64x32 vpx_highbd_8_variance64x32_c
 
-unsigned int vpx_highbd_8_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_8_variance64x64 vpx_highbd_8_variance64x64_c
 
-unsigned int vpx_highbd_8_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x16_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_8_variance8x16 vpx_highbd_8_variance8x16_c
 
-unsigned int vpx_highbd_8_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance8x4 vpx_highbd_8_variance8x4_c
 
-unsigned int vpx_highbd_8_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance8x8 vpx_highbd_8_variance8x8_c
 
-unsigned int vpx_highbd_avg_4x4_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_4x4_c(const uint8_t*, int p);
 #define vpx_highbd_avg_4x4 vpx_highbd_avg_4x4_c
 
-unsigned int vpx_highbd_avg_8x8_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_8x8_c(const uint8_t*, int p);
 #define vpx_highbd_avg_8x8 vpx_highbd_avg_8x8_c
 
-void vpx_highbd_comp_avg_pred_c(uint16_t *comp_pred, const uint8_t *pred8, int width, int height, const uint8_t *ref8, int ref_stride);
+void vpx_highbd_comp_avg_pred_c(uint16_t* comp_pred,
+                                const uint8_t* pred8,
+                                int width,
+                                int height,
+                                const uint8_t* ref8,
+                                int ref_stride);
 #define vpx_highbd_comp_avg_pred vpx_highbd_comp_avg_pred_c
 
-void vpx_highbd_convolve8_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_c(const uint16_t* src,
+                            ptrdiff_t src_stride,
+                            uint16_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h,
+                            int bps);
 #define vpx_highbd_convolve8 vpx_highbd_convolve8_c
 
-void vpx_highbd_convolve8_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
 #define vpx_highbd_convolve8_avg vpx_highbd_convolve8_avg_c
 
-void vpx_highbd_convolve8_avg_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_horiz_c(const uint16_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint16_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h,
+                                      int bps);
 #define vpx_highbd_convolve8_avg_horiz vpx_highbd_convolve8_avg_horiz_c
 
-void vpx_highbd_convolve8_avg_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_vert_c(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
 #define vpx_highbd_convolve8_avg_vert vpx_highbd_convolve8_avg_vert_c
 
-void vpx_highbd_convolve8_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_horiz_c(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
 #define vpx_highbd_convolve8_horiz vpx_highbd_convolve8_horiz_c
 
-void vpx_highbd_convolve8_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_vert_c(const uint16_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint16_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h,
+                                 int bps);
 #define vpx_highbd_convolve8_vert vpx_highbd_convolve8_vert_c
 
-void vpx_highbd_convolve_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_avg_c(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
 #define vpx_highbd_convolve_avg vpx_highbd_convolve_avg_c
 
-void vpx_highbd_convolve_copy_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_copy_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
 #define vpx_highbd_convolve_copy vpx_highbd_convolve_copy_c
 
-void vpx_highbd_d117_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_16x16 vpx_highbd_d117_predictor_16x16_c
 
-void vpx_highbd_d117_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_32x32 vpx_highbd_d117_predictor_32x32_c
 
-void vpx_highbd_d117_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_4x4 vpx_highbd_d117_predictor_4x4_c
 
-void vpx_highbd_d117_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_8x8 vpx_highbd_d117_predictor_8x8_c
 
-void vpx_highbd_d135_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_16x16 vpx_highbd_d135_predictor_16x16_c
 
-void vpx_highbd_d135_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_32x32 vpx_highbd_d135_predictor_32x32_c
 
-void vpx_highbd_d135_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_4x4 vpx_highbd_d135_predictor_4x4_c
 
-void vpx_highbd_d135_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_8x8 vpx_highbd_d135_predictor_8x8_c
 
-void vpx_highbd_d153_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_16x16 vpx_highbd_d153_predictor_16x16_c
 
-void vpx_highbd_d153_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_32x32 vpx_highbd_d153_predictor_32x32_c
 
-void vpx_highbd_d153_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_4x4 vpx_highbd_d153_predictor_4x4_c
 
-void vpx_highbd_d153_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_8x8 vpx_highbd_d153_predictor_8x8_c
 
-void vpx_highbd_d207_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_16x16 vpx_highbd_d207_predictor_16x16_c
 
-void vpx_highbd_d207_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_32x32 vpx_highbd_d207_predictor_32x32_c
 
-void vpx_highbd_d207_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_4x4 vpx_highbd_d207_predictor_4x4_c
 
-void vpx_highbd_d207_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_8x8 vpx_highbd_d207_predictor_8x8_c
 
-void vpx_highbd_d45_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_16x16 vpx_highbd_d45_predictor_16x16_c
 
-void vpx_highbd_d45_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_32x32 vpx_highbd_d45_predictor_32x32_c
 
-void vpx_highbd_d45_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_4x4 vpx_highbd_d45_predictor_4x4_c
 
-void vpx_highbd_d45_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_8x8 vpx_highbd_d45_predictor_8x8_c
 
-void vpx_highbd_d63_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_16x16 vpx_highbd_d63_predictor_16x16_c
 
-void vpx_highbd_d63_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_32x32 vpx_highbd_d63_predictor_32x32_c
 
-void vpx_highbd_d63_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_4x4 vpx_highbd_d63_predictor_4x4_c
 
-void vpx_highbd_d63_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_8x8 vpx_highbd_d63_predictor_8x8_c
 
-void vpx_highbd_dc_128_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_16x16 vpx_highbd_dc_128_predictor_16x16_c
 
-void vpx_highbd_dc_128_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_32x32 vpx_highbd_dc_128_predictor_32x32_c
 
-void vpx_highbd_dc_128_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_4x4 vpx_highbd_dc_128_predictor_4x4_c
 
-void vpx_highbd_dc_128_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_8x8 vpx_highbd_dc_128_predictor_8x8_c
 
-void vpx_highbd_dc_left_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_16x16_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_16x16 vpx_highbd_dc_left_predictor_16x16_c
 
-void vpx_highbd_dc_left_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_32x32_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_32x32 vpx_highbd_dc_left_predictor_32x32_c
 
-void vpx_highbd_dc_left_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_4x4_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_4x4 vpx_highbd_dc_left_predictor_4x4_c
 
-void vpx_highbd_dc_left_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_8x8_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_8x8 vpx_highbd_dc_left_predictor_8x8_c
 
-void vpx_highbd_dc_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_dc_predictor_16x16 vpx_highbd_dc_predictor_16x16_c
 
-void vpx_highbd_dc_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_dc_predictor_32x32 vpx_highbd_dc_predictor_32x32_c
 
-void vpx_highbd_dc_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
 #define vpx_highbd_dc_predictor_4x4 vpx_highbd_dc_predictor_4x4_c
 
-void vpx_highbd_dc_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
 #define vpx_highbd_dc_predictor_8x8 vpx_highbd_dc_predictor_8x8_c
 
-void vpx_highbd_dc_top_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_16x16 vpx_highbd_dc_top_predictor_16x16_c
 
-void vpx_highbd_dc_top_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_32x32 vpx_highbd_dc_top_predictor_32x32_c
 
-void vpx_highbd_dc_top_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_4x4 vpx_highbd_dc_top_predictor_4x4_c
 
-void vpx_highbd_dc_top_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_8x8 vpx_highbd_dc_top_predictor_8x8_c
 
-void vpx_highbd_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
 #define vpx_highbd_fdct16x16 vpx_highbd_fdct16x16_c
 
-void vpx_highbd_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct16x16_1 vpx_highbd_fdct16x16_1_c
 
-void vpx_highbd_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
 #define vpx_highbd_fdct32x32 vpx_highbd_fdct32x32_c
 
-void vpx_highbd_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct32x32_1 vpx_highbd_fdct32x32_1_c
 
-void vpx_highbd_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_rd_c(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
 #define vpx_highbd_fdct32x32_rd vpx_highbd_fdct32x32_rd_c
 
-void vpx_highbd_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_highbd_fdct4x4 vpx_highbd_fdct4x4_c
 
-void vpx_highbd_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_highbd_fdct8x8 vpx_highbd_fdct8x8_c
 
-void vpx_highbd_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_1_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
 #define vpx_highbd_fdct8x8_1 vpx_highbd_fdct8x8_1_c
 
-void vpx_highbd_h_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_16x16 vpx_highbd_h_predictor_16x16_c
 
-void vpx_highbd_h_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_32x32 vpx_highbd_h_predictor_32x32_c
 
-void vpx_highbd_h_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_4x4 vpx_highbd_h_predictor_4x4_c
 
-void vpx_highbd_h_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_8x8 vpx_highbd_h_predictor_8x8_c
 
-void vpx_highbd_idct16x16_10_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_10_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct16x16_10_add vpx_highbd_idct16x16_10_add_c
 
-void vpx_highbd_idct16x16_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
 #define vpx_highbd_idct16x16_1_add vpx_highbd_idct16x16_1_add_c
 
-void vpx_highbd_idct16x16_256_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_256_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
 #define vpx_highbd_idct16x16_256_add vpx_highbd_idct16x16_256_add_c
 
-void vpx_highbd_idct16x16_38_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_38_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct16x16_38_add vpx_highbd_idct16x16_38_add_c
 
-void vpx_highbd_idct32x32_1024_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1024_add_c(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
 #define vpx_highbd_idct32x32_1024_add vpx_highbd_idct32x32_1024_add_c
 
-void vpx_highbd_idct32x32_135_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_135_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
 #define vpx_highbd_idct32x32_135_add vpx_highbd_idct32x32_135_add_c
 
-void vpx_highbd_idct32x32_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
 #define vpx_highbd_idct32x32_1_add vpx_highbd_idct32x32_1_add_c
 
-void vpx_highbd_idct32x32_34_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_34_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct32x32_34_add vpx_highbd_idct32x32_34_add_c
 
-void vpx_highbd_idct4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
 #define vpx_highbd_idct4x4_16_add vpx_highbd_idct4x4_16_add_c
 
-void vpx_highbd_idct4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
 #define vpx_highbd_idct4x4_1_add vpx_highbd_idct4x4_1_add_c
 
-void vpx_highbd_idct8x8_12_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_12_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
 #define vpx_highbd_idct8x8_12_add vpx_highbd_idct8x8_12_add_c
 
-void vpx_highbd_idct8x8_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
 #define vpx_highbd_idct8x8_1_add vpx_highbd_idct8x8_1_add_c
 
-void vpx_highbd_idct8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_64_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
 #define vpx_highbd_idct8x8_64_add vpx_highbd_idct8x8_64_add_c
 
-void vpx_highbd_iwht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
 #define vpx_highbd_iwht4x4_16_add vpx_highbd_iwht4x4_16_add_c
 
-void vpx_highbd_iwht4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
 #define vpx_highbd_iwht4x4_1_add vpx_highbd_iwht4x4_1_add_c
 
-void vpx_highbd_lpf_horizontal_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_c(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
 #define vpx_highbd_lpf_horizontal_16 vpx_highbd_lpf_horizontal_16_c
 
-void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh,
+                                         int bd);
 #define vpx_highbd_lpf_horizontal_16_dual vpx_highbd_lpf_horizontal_16_dual_c
 
-void vpx_highbd_lpf_horizontal_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_4_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
 #define vpx_highbd_lpf_horizontal_4 vpx_highbd_lpf_horizontal_4_c
 
-void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
 #define vpx_highbd_lpf_horizontal_4_dual vpx_highbd_lpf_horizontal_4_dual_c
 
-void vpx_highbd_lpf_horizontal_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_8_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
 #define vpx_highbd_lpf_horizontal_8 vpx_highbd_lpf_horizontal_8_c
 
-void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
 #define vpx_highbd_lpf_horizontal_8_dual vpx_highbd_lpf_horizontal_8_dual_c
 
-void vpx_highbd_lpf_vertical_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_c(uint16_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh,
+                                  int bd);
 #define vpx_highbd_lpf_vertical_16 vpx_highbd_lpf_vertical_16_c
 
-void vpx_highbd_lpf_vertical_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_dual_c(uint16_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh,
+                                       int bd);
 #define vpx_highbd_lpf_vertical_16_dual vpx_highbd_lpf_vertical_16_dual_c
 
-void vpx_highbd_lpf_vertical_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_4_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
 #define vpx_highbd_lpf_vertical_4 vpx_highbd_lpf_vertical_4_c
 
-void vpx_highbd_lpf_vertical_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_4_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
 #define vpx_highbd_lpf_vertical_4_dual vpx_highbd_lpf_vertical_4_dual_c
 
-void vpx_highbd_lpf_vertical_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_8_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
 #define vpx_highbd_lpf_vertical_8 vpx_highbd_lpf_vertical_8_c
 
-void vpx_highbd_lpf_vertical_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_8_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
 #define vpx_highbd_lpf_vertical_8_dual vpx_highbd_lpf_vertical_8_dual_c
 
-void vpx_highbd_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_highbd_minmax_8x8_c(const uint8_t* s,
+                             int p,
+                             const uint8_t* d,
+                             int dp,
+                             int* min,
+                             int* max);
 #define vpx_highbd_minmax_8x8 vpx_highbd_minmax_8x8_c
 
-void vpx_highbd_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* zbin_ptr,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             const int16_t* quant_shift_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vpx_highbd_quantize_b vpx_highbd_quantize_b_c
 
-void vpx_highbd_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
 #define vpx_highbd_quantize_b_32x32 vpx_highbd_quantize_b_32x32_c
 
-unsigned int vpx_highbd_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
 #define vpx_highbd_sad16x16 vpx_highbd_sad16x16_c
 
-unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
 #define vpx_highbd_sad16x16_avg vpx_highbd_sad16x16_avg_c
 
-void vpx_highbd_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
 #define vpx_highbd_sad16x16x4d vpx_highbd_sad16x16x4d_c
 
-unsigned int vpx_highbd_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
 #define vpx_highbd_sad16x32 vpx_highbd_sad16x32_c
 
-unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
 #define vpx_highbd_sad16x32_avg vpx_highbd_sad16x32_avg_c
 
-void vpx_highbd_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
 #define vpx_highbd_sad16x32x4d vpx_highbd_sad16x32x4d_c
 
-unsigned int vpx_highbd_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x8_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
 #define vpx_highbd_sad16x8 vpx_highbd_sad16x8_c
 
-unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
 #define vpx_highbd_sad16x8_avg vpx_highbd_sad16x8_avg_c
 
-void vpx_highbd_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x8x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
 #define vpx_highbd_sad16x8x4d vpx_highbd_sad16x8x4d_c
 
-unsigned int vpx_highbd_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
 #define vpx_highbd_sad32x16 vpx_highbd_sad32x16_c
 
-unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
 #define vpx_highbd_sad32x16_avg vpx_highbd_sad32x16_avg_c
 
-void vpx_highbd_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
 #define vpx_highbd_sad32x16x4d vpx_highbd_sad32x16x4d_c
 
-unsigned int vpx_highbd_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
 #define vpx_highbd_sad32x32 vpx_highbd_sad32x32_c
 
-unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
 #define vpx_highbd_sad32x32_avg vpx_highbd_sad32x32_avg_c
 
-void vpx_highbd_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
 #define vpx_highbd_sad32x32x4d vpx_highbd_sad32x32x4d_c
 
-unsigned int vpx_highbd_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
 #define vpx_highbd_sad32x64 vpx_highbd_sad32x64_c
 
-unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
 #define vpx_highbd_sad32x64_avg vpx_highbd_sad32x64_avg_c
 
-void vpx_highbd_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
 #define vpx_highbd_sad32x64x4d vpx_highbd_sad32x64x4d_c
 
-unsigned int vpx_highbd_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x4 vpx_highbd_sad4x4_c
 
-unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x4_avg vpx_highbd_sad4x4_avg_c
 
-void vpx_highbd_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
 #define vpx_highbd_sad4x4x4d vpx_highbd_sad4x4x4d_c
 
-unsigned int vpx_highbd_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x8 vpx_highbd_sad4x8_c
 
-unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x8_avg vpx_highbd_sad4x8_avg_c
 
-void vpx_highbd_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
 #define vpx_highbd_sad4x8x4d vpx_highbd_sad4x8x4d_c
 
-unsigned int vpx_highbd_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
 #define vpx_highbd_sad64x32 vpx_highbd_sad64x32_c
 
-unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
 #define vpx_highbd_sad64x32_avg vpx_highbd_sad64x32_avg_c
 
-void vpx_highbd_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
 #define vpx_highbd_sad64x32x4d vpx_highbd_sad64x32x4d_c
 
-unsigned int vpx_highbd_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
 #define vpx_highbd_sad64x64 vpx_highbd_sad64x64_c
 
-unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
 #define vpx_highbd_sad64x64_avg vpx_highbd_sad64x64_avg_c
 
-void vpx_highbd_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
 #define vpx_highbd_sad64x64x4d vpx_highbd_sad64x64x4d_c
 
-unsigned int vpx_highbd_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
 #define vpx_highbd_sad8x16 vpx_highbd_sad8x16_c
 
-unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
 #define vpx_highbd_sad8x16_avg vpx_highbd_sad8x16_avg_c
 
-void vpx_highbd_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
 #define vpx_highbd_sad8x16x4d vpx_highbd_sad8x16x4d_c
 
-unsigned int vpx_highbd_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad8x4 vpx_highbd_sad8x4_c
 
-unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad8x4_avg vpx_highbd_sad8x4_avg_c
 
-void vpx_highbd_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
 #define vpx_highbd_sad8x4x4d vpx_highbd_sad8x4x4d_c
 
-unsigned int vpx_highbd_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad8x8 vpx_highbd_sad8x8_c
 
-unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad8x8_avg vpx_highbd_sad8x8_avg_c
 
-void vpx_highbd_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
 #define vpx_highbd_sad8x8x4d vpx_highbd_sad8x8x4d_c
 
-void vpx_highbd_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride, int bd);
+void vpx_highbd_subtract_block_c(int rows,
+                                 int cols,
+                                 int16_t* diff_ptr,
+                                 ptrdiff_t diff_stride,
+                                 const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 const uint8_t* pred_ptr,
+                                 ptrdiff_t pred_stride,
+                                 int bd);
 #define vpx_highbd_subtract_block vpx_highbd_subtract_block_c
 
-void vpx_highbd_tm_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_tm_predictor_16x16 vpx_highbd_tm_predictor_16x16_c
 
-void vpx_highbd_tm_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_tm_predictor_32x32 vpx_highbd_tm_predictor_32x32_c
 
-void vpx_highbd_tm_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
 #define vpx_highbd_tm_predictor_4x4 vpx_highbd_tm_predictor_4x4_c
 
-void vpx_highbd_tm_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
 #define vpx_highbd_tm_predictor_8x8 vpx_highbd_tm_predictor_8x8_c
 
-void vpx_highbd_v_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_v_predictor_16x16 vpx_highbd_v_predictor_16x16_c
 
-void vpx_highbd_v_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_v_predictor_32x32 vpx_highbd_v_predictor_32x32_c
 
-void vpx_highbd_v_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_v_predictor_4x4 vpx_highbd_v_predictor_4x4_c
 
-void vpx_highbd_v_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_v_predictor_8x8 vpx_highbd_v_predictor_8x8_c
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_10_add vpx_idct16x16_10_add_c
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_1_add vpx_idct16x16_1_add_c
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct16x16_256_add vpx_idct16x16_256_add_c
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_38_add vpx_idct16x16_38_add_c
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct32x32_1024_add vpx_idct32x32_1024_add_c
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct32x32_135_add vpx_idct32x32_135_add_c
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct32x32_1_add vpx_idct32x32_1_add_c
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct32x32_34_add vpx_idct32x32_34_add_c
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_16_add vpx_idct4x4_16_add_c
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_1_add vpx_idct4x4_1_add_c
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_12_add vpx_idct8x8_12_add_c
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_1_add vpx_idct8x8_1_add_c
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_64_add vpx_idct8x8_64_add_c
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
 #define vpx_int_pro_col vpx_int_pro_col_c
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
 #define vpx_int_pro_row vpx_int_pro_row_c
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_16_add vpx_iwht4x4_16_add_c
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_horizontal_16 vpx_lpf_horizontal_16_c
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
 #define vpx_lpf_horizontal_16_dual vpx_lpf_horizontal_16_dual_c
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
 #define vpx_lpf_horizontal_4 vpx_lpf_horizontal_4_c
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
 #define vpx_lpf_horizontal_4_dual vpx_lpf_horizontal_4_dual_c
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
 #define vpx_lpf_horizontal_8 vpx_lpf_horizontal_8_c
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
 #define vpx_lpf_horizontal_8_dual vpx_lpf_horizontal_8_dual_c
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
 #define vpx_lpf_vertical_16 vpx_lpf_vertical_16_c
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
 #define vpx_lpf_vertical_16_dual vpx_lpf_vertical_16_dual_c
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
 #define vpx_lpf_vertical_4 vpx_lpf_vertical_4_c
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
 #define vpx_lpf_vertical_4_dual vpx_lpf_vertical_4_dual_c
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
 #define vpx_lpf_vertical_8 vpx_lpf_vertical_8_c
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
 #define vpx_lpf_vertical_8_dual vpx_lpf_vertical_8_dual_c
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
 #define vpx_mbpost_proc_across_ip vpx_mbpost_proc_across_ip_c
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
 #define vpx_mbpost_proc_down vpx_mbpost_proc_down_c
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
 #define vpx_minmax_8x8 vpx_minmax_8x8_c
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
 #define vpx_mse16x16 vpx_mse16x16_c
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse16x8 vpx_mse16x8_c
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse8x16 vpx_mse8x16_c
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
 #define vpx_mse8x8 vpx_mse8x8_c
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
 #define vpx_plane_add_noise vpx_plane_add_noise_c
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-#define vpx_post_proc_down_and_across_mb_row vpx_post_proc_down_and_across_mb_row_c
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+#define vpx_post_proc_down_and_across_mb_row \
+  vpx_post_proc_down_and_across_mb_row_c
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
 #define vpx_quantize_b vpx_quantize_b_c
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vpx_quantize_b_32x32 vpx_quantize_b_32x32_c
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad16x16 vpx_sad16x16_c
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad16x16_avg vpx_sad16x16_avg_c
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x3 vpx_sad16x16x3_c
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad16x16x4d vpx_sad16x16x4d_c
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x8 vpx_sad16x16x8_c
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad16x32 vpx_sad16x32_c
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad16x32_avg vpx_sad16x32_avg_c
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad16x32x4d vpx_sad16x32x4d_c
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
 #define vpx_sad16x8 vpx_sad16x8_c
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
 #define vpx_sad16x8_avg vpx_sad16x8_avg_c
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x3 vpx_sad16x8x3_c
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x8x4d vpx_sad16x8x4d_c
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x8 vpx_sad16x8x8_c
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x16 vpx_sad32x16_c
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x16_avg vpx_sad32x16_avg_c
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x16x4d vpx_sad32x16x4d_c
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x32 vpx_sad32x32_c
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x32_avg vpx_sad32x32_avg_c
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x32x4d vpx_sad32x32x4d_c
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x64 vpx_sad32x64_c
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x64_avg vpx_sad32x64_avg_c
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x64x4d vpx_sad32x64x4d_c
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad4x4 vpx_sad4x4_c
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad4x4_avg vpx_sad4x4_avg_c
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x3 vpx_sad4x4x3_c
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad4x4x4d vpx_sad4x4x4d_c
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x8 vpx_sad4x4x8_c
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad4x8 vpx_sad4x8_c
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad4x8_avg vpx_sad4x8_avg_c
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad4x8x4d vpx_sad4x8x4d_c
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad64x32 vpx_sad64x32_c
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad64x32_avg vpx_sad64x32_avg_c
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad64x32x4d vpx_sad64x32x4d_c
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad64x64 vpx_sad64x64_c
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad64x64_avg vpx_sad64x64_avg_c
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad64x64x4d vpx_sad64x64x4d_c
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
 #define vpx_sad8x16 vpx_sad8x16_c
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
 #define vpx_sad8x16_avg vpx_sad8x16_avg_c
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x3 vpx_sad8x16x3_c
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad8x16x4d vpx_sad8x16x4d_c
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x8 vpx_sad8x16x8_c
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad8x4 vpx_sad8x4_c
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad8x4_avg vpx_sad8x4_avg_c
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x4x4d vpx_sad8x4x4d_c
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad8x8 vpx_sad8x8_c
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad8x8_avg vpx_sad8x8_avg_c
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x3 vpx_sad8x8x3_c
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x8x4d vpx_sad8x8x4d_c
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x8 vpx_sad8x8x8_c
 
-int vpx_satd_c(const tran_low_t *coeff, int length);
+int vpx_satd_c(const tran_low_t* coeff, int length);
 #define vpx_satd vpx_satd_c
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_scaled_2d vpx_scaled_2d_c
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x16 vpx_sub_pixel_avg_variance16x16_c
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x32 vpx_sub_pixel_avg_variance16x32_c
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x8 vpx_sub_pixel_avg_variance16x8_c
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x16 vpx_sub_pixel_avg_variance32x16_c
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x32 vpx_sub_pixel_avg_variance32x32_c
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x64 vpx_sub_pixel_avg_variance32x64_c
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x4 vpx_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x8 vpx_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x32 vpx_sub_pixel_avg_variance64x32_c
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x64 vpx_sub_pixel_avg_variance64x64_c
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x16 vpx_sub_pixel_avg_variance8x16_c
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x4 vpx_sub_pixel_avg_variance8x4_c
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x8 vpx_sub_pixel_avg_variance8x8_c
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance16x16 vpx_sub_pixel_variance16x16_c
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance16x32 vpx_sub_pixel_variance16x32_c
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
 #define vpx_sub_pixel_variance16x8 vpx_sub_pixel_variance16x8_c
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x16 vpx_sub_pixel_variance32x16_c
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x32 vpx_sub_pixel_variance32x32_c
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x64 vpx_sub_pixel_variance32x64_c
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance4x4 vpx_sub_pixel_variance4x4_c
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance4x8 vpx_sub_pixel_variance4x8_c
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance64x32 vpx_sub_pixel_variance64x32_c
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance64x64 vpx_sub_pixel_variance64x64_c
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
 #define vpx_sub_pixel_variance8x16 vpx_sub_pixel_variance8x16_c
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance8x4 vpx_sub_pixel_variance8x4_c
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance8x8 vpx_sub_pixel_variance8x8_c
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
 #define vpx_subtract_block vpx_subtract_block_c
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
 #define vpx_sum_squares_2d_i16 vpx_sum_squares_2d_i16_c
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_tm_predictor_16x16 vpx_tm_predictor_16x16_c
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_tm_predictor_32x32 vpx_tm_predictor_32x32_c
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_tm_predictor_4x4 vpx_tm_predictor_4x4_c
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_tm_predictor_8x8 vpx_tm_predictor_8x8_c
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_v_predictor_16x16 vpx_v_predictor_16x16_c
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_v_predictor_32x32 vpx_v_predictor_32x32_c
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_v_predictor_4x4 vpx_v_predictor_4x4_c
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_v_predictor_8x8 vpx_v_predictor_8x8_c
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance16x16 vpx_variance16x16_c
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance16x32 vpx_variance16x32_c
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
 #define vpx_variance16x8 vpx_variance16x8_c
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x16 vpx_variance32x16_c
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x32 vpx_variance32x32_c
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x64 vpx_variance32x64_c
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance4x4 vpx_variance4x4_c
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance4x8 vpx_variance4x8_c
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance64x32 vpx_variance64x32_c
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance64x64 vpx_variance64x64_c
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
 #define vpx_variance8x16 vpx_variance8x16_c
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance8x4 vpx_variance8x4_c
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance8x8 vpx_variance8x8_c
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
 #define vpx_vector_var vpx_vector_var_c
 
 void vpx_dsp_rtcd(void);
@@ -1512,9 +3804,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/linux/generic/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/generic/vpx_scale_rtcd.h b/third_party/libvpx/source/config/linux/generic/vpx_scale_rtcd.h
index 0098208..6686511 100644
--- a/third_party/libvpx/source/config/linux/generic/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/linux/generic/vpx_scale_rtcd.h
@@ -13,43 +13,71 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
@@ -57,9 +85,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/linux/ia32/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/ia32/vp8_rtcd.h b/third_party/libvpx/source/config/linux/ia32/vp8_rtcd.h
index 3addf41..2f3a2d3 100644
--- a/third_party/libvpx/source/config/linux/ia32/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/linux/ia32/vp8_rtcd.h
@@ -26,303 +26,868 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict16x16)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+void vp8_bilinear_predict16x16_sse2(unsigned char* src,
+                                    int src_pitch,
+                                    int xofst,
+                                    int yofst,
+                                    unsigned char* dst,
+                                    int dst_pitch);
+void vp8_bilinear_predict16x16_ssse3(unsigned char* src,
+                                     int src_pitch,
+                                     int xofst,
+                                     int yofst,
+                                     unsigned char* dst,
+                                     int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict16x16)(unsigned char* src,
+                                              int src_pitch,
+                                              int xofst,
+                                              int yofst,
+                                              unsigned char* dst,
+                                              int dst_pitch);
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict4x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict4x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict4x4_mmx(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict4x4)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict8x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x4_mmx(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict8x4)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict8x8)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x8_sse2(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+void vp8_bilinear_predict8x8_ssse3(unsigned char* src,
+                                   int src_pitch,
+                                   int xofst,
+                                   int yofst,
+                                   unsigned char* dst,
+                                   int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict8x8)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
-int vp8_block_error_sse2(short *coeff, short *dqcoeff);
-RTCD_EXTERN int (*vp8_block_error)(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
+int vp8_block_error_sse2(short* coeff, short* dqcoeff);
+RTCD_EXTERN int (*vp8_block_error)(short* coeff, short* dqcoeff);
 
-void vp8_copy32xn_c(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-void vp8_copy32xn_sse2(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-void vp8_copy32xn_sse3(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-RTCD_EXTERN void (*vp8_copy32xn)(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
+void vp8_copy32xn_c(const unsigned char* src_ptr,
+                    int source_stride,
+                    unsigned char* dst_ptr,
+                    int dst_stride,
+                    int n);
+void vp8_copy32xn_sse2(const unsigned char* src_ptr,
+                       int source_stride,
+                       unsigned char* dst_ptr,
+                       int dst_stride,
+                       int n);
+void vp8_copy32xn_sse3(const unsigned char* src_ptr,
+                       int source_stride,
+                       unsigned char* dst_ptr,
+                       int dst_stride,
+                       int n);
+RTCD_EXTERN void (*vp8_copy32xn)(const unsigned char* src_ptr,
+                                 int source_stride,
+                                 unsigned char* dst_ptr,
+                                 int dst_stride,
+                                 int n);
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem16x16_sse2(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_copy_mem16x16)(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+void vp8_copy_mem16x16_sse2(unsigned char* src,
+                            int src_pitch,
+                            unsigned char* dst,
+                            int dst_pitch);
+RTCD_EXTERN void (*vp8_copy_mem16x16)(unsigned char* src,
+                                      int src_pitch,
+                                      unsigned char* dst,
+                                      int dst_pitch);
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x4_mmx(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_copy_mem8x4)(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x4_mmx(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+RTCD_EXTERN void (*vp8_copy_mem8x4)(unsigned char* src,
+                                    int src_pitch,
+                                    unsigned char* dst,
+                                    int dst_pitch);
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x8_mmx(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_copy_mem8x8)(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x8_mmx(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+RTCD_EXTERN void (*vp8_copy_mem8x8)(unsigned char* src,
+                                    int src_pitch,
+                                    unsigned char* dst,
+                                    int dst_pitch);
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-void vp8_dc_only_idct_add_mmx(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-RTCD_EXTERN void (*vp8_dc_only_idct_add)(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_dc_only_idct_add_mmx(short input,
+                              unsigned char* pred,
+                              int pred_stride,
+                              unsigned char* dst,
+                              int dst_stride);
+RTCD_EXTERN void (*vp8_dc_only_idct_add)(short input,
+                                         unsigned char* pred,
+                                         int pred_stride,
+                                         unsigned char* dst,
+                                         int dst_stride);
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_sse2(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-RTCD_EXTERN int (*vp8_denoiser_filter)(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
+int vp8_denoiser_filter_sse2(unsigned char* mc_running_avg_y,
+                             int mc_avg_y_stride,
+                             unsigned char* running_avg_y,
+                             int avg_y_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+RTCD_EXTERN int (*vp8_denoiser_filter)(unsigned char* mc_running_avg_y,
+                                       int mc_avg_y_stride,
+                                       unsigned char* running_avg_y,
+                                       int avg_y_stride,
+                                       unsigned char* sig,
+                                       int sig_stride,
+                                       unsigned int motion_magnitude,
+                                       int increase_denoising);
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_uv_sse2(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-RTCD_EXTERN int (*vp8_denoiser_filter_uv)(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+int vp8_denoiser_filter_uv_sse2(unsigned char* mc_running_avg,
+                                int mc_avg_stride,
+                                unsigned char* running_avg,
+                                int avg_stride,
+                                unsigned char* sig,
+                                int sig_stride,
+                                unsigned int motion_magnitude,
+                                int increase_denoising);
+RTCD_EXTERN int (*vp8_denoiser_filter_uv)(unsigned char* mc_running_avg,
+                                          int mc_avg_stride,
+                                          unsigned char* running_avg,
+                                          int avg_stride,
+                                          unsigned char* sig,
+                                          int sig_stride,
+                                          unsigned int motion_magnitude,
+                                          int increase_denoising);
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
-void vp8_dequant_idct_add_mmx(short *input, short *dq, unsigned char *output, int stride);
-RTCD_EXTERN void (*vp8_dequant_idct_add)(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
+void vp8_dequant_idct_add_mmx(short* input,
+                              short* dq,
+                              unsigned char* output,
+                              int stride);
+RTCD_EXTERN void (*vp8_dequant_idct_add)(short* input,
+                                         short* dq,
+                                         unsigned char* output,
+                                         int stride);
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-void vp8_dequant_idct_add_uv_block_sse2(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-RTCD_EXTERN void (*vp8_dequant_idct_add_uv_block)(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
+void vp8_dequant_idct_add_uv_block_sse2(short* q,
+                                        short* dq,
+                                        unsigned char* dst_u,
+                                        unsigned char* dst_v,
+                                        int stride,
+                                        char* eobs);
+RTCD_EXTERN void (*vp8_dequant_idct_add_uv_block)(short* q,
+                                                  short* dq,
+                                                  unsigned char* dst_u,
+                                                  unsigned char* dst_v,
+                                                  int stride,
+                                                  char* eobs);
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-void vp8_dequant_idct_add_y_block_sse2(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-RTCD_EXTERN void (*vp8_dequant_idct_add_y_block)(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
+void vp8_dequant_idct_add_y_block_sse2(short* q,
+                                       short* dq,
+                                       unsigned char* dst,
+                                       int stride,
+                                       char* eobs);
+RTCD_EXTERN void (*vp8_dequant_idct_add_y_block)(short* q,
+                                                 short* dq,
+                                                 unsigned char* dst,
+                                                 int stride,
+                                                 char* eobs);
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
-void vp8_dequantize_b_mmx(struct blockd*, short *dqc);
-RTCD_EXTERN void (*vp8_dequantize_b)(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
+void vp8_dequantize_b_mmx(struct blockd*, short* dqc);
+RTCD_EXTERN void (*vp8_dequantize_b)(struct blockd*, short* dqc);
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_diamond_search_sadx4(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-RTCD_EXTERN int (*vp8_diamond_search_sad)(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
+int vp8_diamond_search_sadx4(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
+RTCD_EXTERN int (*vp8_diamond_search_sad)(struct macroblock* x,
+                                          struct block* b,
+                                          struct blockd* d,
+                                          union int_mv* ref_mv,
+                                          union int_mv* best_mv,
+                                          int search_param,
+                                          int sad_per_bit,
+                                          int* num00,
+                                          struct variance_vtable* fn_ptr,
+                                          int* mvcost[2],
+                                          union int_mv* center_mv);
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
-void vp8_fast_quantize_b_sse2(struct block *, struct blockd *);
-void vp8_fast_quantize_b_ssse3(struct block *, struct blockd *);
-RTCD_EXTERN void (*vp8_fast_quantize_b)(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
+void vp8_fast_quantize_b_sse2(struct block*, struct blockd*);
+void vp8_fast_quantize_b_ssse3(struct block*, struct blockd*);
+RTCD_EXTERN void (*vp8_fast_quantize_b)(struct block*, struct blockd*);
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-void vp8_filter_by_weight16x16_sse2(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-RTCD_EXTERN void (*vp8_filter_by_weight16x16)(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
+void vp8_filter_by_weight16x16_sse2(unsigned char* src,
+                                    int src_stride,
+                                    unsigned char* dst,
+                                    int dst_stride,
+                                    int src_weight);
+RTCD_EXTERN void (*vp8_filter_by_weight16x16)(unsigned char* src,
+                                              int src_stride,
+                                              unsigned char* dst,
+                                              int dst_stride,
+                                              int src_weight);
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-void vp8_filter_by_weight8x8_sse2(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-RTCD_EXTERN void (*vp8_filter_by_weight8x8)(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
+void vp8_filter_by_weight8x8_sse2(unsigned char* src,
+                                  int src_stride,
+                                  unsigned char* dst,
+                                  int dst_stride,
+                                  int src_weight);
+RTCD_EXTERN void (*vp8_filter_by_weight8x8)(unsigned char* src,
+                                            int src_stride,
+                                            unsigned char* dst,
+                                            int dst_stride,
+                                            int src_weight);
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_full_search_sadx3(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_full_search_sadx8(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-RTCD_EXTERN int (*vp8_full_search_sad)(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+int vp8_full_search_sadx3(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+int vp8_full_search_sadx8(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+RTCD_EXTERN int (*vp8_full_search_sad)(struct macroblock* x,
+                                       struct block* b,
+                                       struct blockd* d,
+                                       union int_mv* ref_mv,
+                                       int sad_per_bit,
+                                       int distance,
+                                       struct variance_vtable* fn_ptr,
+                                       int* mvcost[2],
+                                       union int_mv* center_mv);
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bh_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_bh)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bh_sse2(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_bh)(unsigned char* y,
+                                       unsigned char* u,
+                                       unsigned char* v,
+                                       int ystride,
+                                       int uv_stride,
+                                       struct loop_filter_info* lfi);
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bv_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_bv)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bv_sse2(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_bv)(unsigned char* y,
+                                       unsigned char* u,
+                                       unsigned char* v,
+                                       int ystride,
+                                       int uv_stride,
+                                       struct loop_filter_info* lfi);
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbh_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_mbh)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbh_sse2(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_mbh)(unsigned char* y,
+                                        unsigned char* u,
+                                        unsigned char* v,
+                                        int ystride,
+                                        int uv_stride,
+                                        struct loop_filter_info* lfi);
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbv_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_mbv)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbv_sse2(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_mbv)(unsigned char* y,
+                                        unsigned char* u,
+                                        unsigned char* v,
+                                        int ystride,
+                                        int uv_stride,
+                                        struct loop_filter_info* lfi);
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bhs_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_bh)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bhs_sse2(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_bh)(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bvs_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_bv)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bvs_sse2(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_bv)(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_simple_horizontal_edge_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_mbh)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
+void vp8_loop_filter_simple_horizontal_edge_sse2(unsigned char* y,
+                                                 int ystride,
+                                                 const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_mbh)(unsigned char* y,
+                                               int ystride,
+                                               const unsigned char* blimit);
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_simple_vertical_edge_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_mbv)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
+void vp8_loop_filter_simple_vertical_edge_sse2(unsigned char* y,
+                                               int ystride,
+                                               const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_mbv)(unsigned char* y,
+                                               int ystride,
+                                               const unsigned char* blimit);
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
-int vp8_mbblock_error_sse2(struct macroblock *mb, int dc);
-RTCD_EXTERN int (*vp8_mbblock_error)(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
+int vp8_mbblock_error_sse2(struct macroblock* mb, int dc);
+RTCD_EXTERN int (*vp8_mbblock_error)(struct macroblock* mb, int dc);
 
-int vp8_mbuverror_c(struct macroblock *mb);
-int vp8_mbuverror_sse2(struct macroblock *mb);
-RTCD_EXTERN int (*vp8_mbuverror)(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
+int vp8_mbuverror_sse2(struct macroblock* mb);
+RTCD_EXTERN int (*vp8_mbuverror)(struct macroblock* mb);
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_refining_search_sadx4(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-RTCD_EXTERN int (*vp8_refining_search_sad)(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
+int vp8_refining_search_sadx4(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
+RTCD_EXTERN int (*vp8_refining_search_sad)(struct macroblock* x,
+                                           struct block* b,
+                                           struct blockd* d,
+                                           union int_mv* ref_mv,
+                                           int sad_per_bit,
+                                           int distance,
+                                           struct variance_vtable* fn_ptr,
+                                           int* mvcost[2],
+                                           union int_mv* center_mv);
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
-void vp8_regular_quantize_b_sse2(struct block *, struct blockd *);
-void vp8_regular_quantize_b_sse4_1(struct block *, struct blockd *);
-RTCD_EXTERN void (*vp8_regular_quantize_b)(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
+void vp8_regular_quantize_b_sse2(struct block*, struct blockd*);
+void vp8_regular_quantize_b_sse4_1(struct block*, struct blockd*);
+RTCD_EXTERN void (*vp8_regular_quantize_b)(struct block*, struct blockd*);
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct4x4_sse2(short *input, short *output, int pitch);
-RTCD_EXTERN void (*vp8_short_fdct4x4)(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct4x4_sse2(short* input, short* output, int pitch);
+RTCD_EXTERN void (*vp8_short_fdct4x4)(short* input, short* output, int pitch);
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct8x4_sse2(short *input, short *output, int pitch);
-RTCD_EXTERN void (*vp8_short_fdct8x4)(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct8x4_sse2(short* input, short* output, int pitch);
+RTCD_EXTERN void (*vp8_short_fdct8x4)(short* input, short* output, int pitch);
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-void vp8_short_idct4x4llm_mmx(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-RTCD_EXTERN void (*vp8_short_idct4x4llm)(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_short_idct4x4llm_mmx(short* input,
+                              unsigned char* pred,
+                              int pitch,
+                              unsigned char* dst,
+                              int dst_stride);
+RTCD_EXTERN void (*vp8_short_idct4x4llm)(short* input,
+                                         unsigned char* pred,
+                                         int pitch,
+                                         unsigned char* dst,
+                                         int dst_stride);
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
-void vp8_short_inv_walsh4x4_sse2(short *input, short *output);
-RTCD_EXTERN void (*vp8_short_inv_walsh4x4)(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
+void vp8_short_inv_walsh4x4_sse2(short* input, short* output);
+RTCD_EXTERN void (*vp8_short_inv_walsh4x4)(short* input, short* output);
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
-void vp8_short_walsh4x4_sse2(short *input, short *output, int pitch);
-RTCD_EXTERN void (*vp8_short_walsh4x4)(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
+void vp8_short_walsh4x4_sse2(short* input, short* output, int pitch);
+RTCD_EXTERN void (*vp8_short_walsh4x4)(short* input, short* output, int pitch);
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict16x16)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict16x16_sse2(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+void vp8_sixtap_predict16x16_ssse3(unsigned char* src,
+                                   int src_pitch,
+                                   int xofst,
+                                   int yofst,
+                                   unsigned char* dst,
+                                   int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict16x16)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict4x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict4x4_mmx(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict4x4_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict4x4)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict8x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x4_sse2(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+void vp8_sixtap_predict8x4_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict8x4)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict8x8)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x8_sse2(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+void vp8_sixtap_predict8x8_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict8x8)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
 void vp8_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_c;
-    if (flags & HAS_SSE2) vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_sse2;
-    if (flags & HAS_SSSE3) vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_ssse3;
-    vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_c;
-    if (flags & HAS_MMX) vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_mmx;
-    vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_c;
-    if (flags & HAS_MMX) vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_mmx;
-    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_c;
-    if (flags & HAS_SSE2) vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_sse2;
-    if (flags & HAS_SSSE3) vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_ssse3;
-    vp8_block_error = vp8_block_error_c;
-    if (flags & HAS_SSE2) vp8_block_error = vp8_block_error_sse2;
-    vp8_copy32xn = vp8_copy32xn_c;
-    if (flags & HAS_SSE2) vp8_copy32xn = vp8_copy32xn_sse2;
-    if (flags & HAS_SSE3) vp8_copy32xn = vp8_copy32xn_sse3;
-    vp8_copy_mem16x16 = vp8_copy_mem16x16_c;
-    if (flags & HAS_SSE2) vp8_copy_mem16x16 = vp8_copy_mem16x16_sse2;
-    vp8_copy_mem8x4 = vp8_copy_mem8x4_c;
-    if (flags & HAS_MMX) vp8_copy_mem8x4 = vp8_copy_mem8x4_mmx;
-    vp8_copy_mem8x8 = vp8_copy_mem8x8_c;
-    if (flags & HAS_MMX) vp8_copy_mem8x8 = vp8_copy_mem8x8_mmx;
-    vp8_dc_only_idct_add = vp8_dc_only_idct_add_c;
-    if (flags & HAS_MMX) vp8_dc_only_idct_add = vp8_dc_only_idct_add_mmx;
-    vp8_denoiser_filter = vp8_denoiser_filter_c;
-    if (flags & HAS_SSE2) vp8_denoiser_filter = vp8_denoiser_filter_sse2;
-    vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_c;
-    if (flags & HAS_SSE2) vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_sse2;
-    vp8_dequant_idct_add = vp8_dequant_idct_add_c;
-    if (flags & HAS_MMX) vp8_dequant_idct_add = vp8_dequant_idct_add_mmx;
-    vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_c;
-    if (flags & HAS_SSE2) vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_sse2;
-    vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_c;
-    if (flags & HAS_SSE2) vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_sse2;
-    vp8_dequantize_b = vp8_dequantize_b_c;
-    if (flags & HAS_MMX) vp8_dequantize_b = vp8_dequantize_b_mmx;
-    vp8_diamond_search_sad = vp8_diamond_search_sad_c;
-    if (flags & HAS_SSE2) vp8_diamond_search_sad = vp8_diamond_search_sadx4;
-    vp8_fast_quantize_b = vp8_fast_quantize_b_c;
-    if (flags & HAS_SSE2) vp8_fast_quantize_b = vp8_fast_quantize_b_sse2;
-    if (flags & HAS_SSSE3) vp8_fast_quantize_b = vp8_fast_quantize_b_ssse3;
-    vp8_filter_by_weight16x16 = vp8_filter_by_weight16x16_c;
-    if (flags & HAS_SSE2) vp8_filter_by_weight16x16 = vp8_filter_by_weight16x16_sse2;
-    vp8_filter_by_weight8x8 = vp8_filter_by_weight8x8_c;
-    if (flags & HAS_SSE2) vp8_filter_by_weight8x8 = vp8_filter_by_weight8x8_sse2;
-    vp8_full_search_sad = vp8_full_search_sad_c;
-    if (flags & HAS_SSE3) vp8_full_search_sad = vp8_full_search_sadx3;
-    if (flags & HAS_SSE4_1) vp8_full_search_sad = vp8_full_search_sadx8;
-    vp8_loop_filter_bh = vp8_loop_filter_bh_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_bh = vp8_loop_filter_bh_sse2;
-    vp8_loop_filter_bv = vp8_loop_filter_bv_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_bv = vp8_loop_filter_bv_sse2;
-    vp8_loop_filter_mbh = vp8_loop_filter_mbh_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_mbh = vp8_loop_filter_mbh_sse2;
-    vp8_loop_filter_mbv = vp8_loop_filter_mbv_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_mbv = vp8_loop_filter_mbv_sse2;
-    vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_sse2;
-    vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_sse2;
-    vp8_loop_filter_simple_mbh = vp8_loop_filter_simple_horizontal_edge_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_simple_mbh = vp8_loop_filter_simple_horizontal_edge_sse2;
-    vp8_loop_filter_simple_mbv = vp8_loop_filter_simple_vertical_edge_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_simple_mbv = vp8_loop_filter_simple_vertical_edge_sse2;
-    vp8_mbblock_error = vp8_mbblock_error_c;
-    if (flags & HAS_SSE2) vp8_mbblock_error = vp8_mbblock_error_sse2;
-    vp8_mbuverror = vp8_mbuverror_c;
-    if (flags & HAS_SSE2) vp8_mbuverror = vp8_mbuverror_sse2;
-    vp8_refining_search_sad = vp8_refining_search_sad_c;
-    if (flags & HAS_SSE2) vp8_refining_search_sad = vp8_refining_search_sadx4;
-    vp8_regular_quantize_b = vp8_regular_quantize_b_c;
-    if (flags & HAS_SSE2) vp8_regular_quantize_b = vp8_regular_quantize_b_sse2;
-    if (flags & HAS_SSE4_1) vp8_regular_quantize_b = vp8_regular_quantize_b_sse4_1;
-    vp8_short_fdct4x4 = vp8_short_fdct4x4_c;
-    if (flags & HAS_SSE2) vp8_short_fdct4x4 = vp8_short_fdct4x4_sse2;
-    vp8_short_fdct8x4 = vp8_short_fdct8x4_c;
-    if (flags & HAS_SSE2) vp8_short_fdct8x4 = vp8_short_fdct8x4_sse2;
-    vp8_short_idct4x4llm = vp8_short_idct4x4llm_c;
-    if (flags & HAS_MMX) vp8_short_idct4x4llm = vp8_short_idct4x4llm_mmx;
-    vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_c;
-    if (flags & HAS_SSE2) vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_sse2;
-    vp8_short_walsh4x4 = vp8_short_walsh4x4_c;
-    if (flags & HAS_SSE2) vp8_short_walsh4x4 = vp8_short_walsh4x4_sse2;
-    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_c;
-    if (flags & HAS_SSE2) vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_ssse3;
-    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_c;
-    if (flags & HAS_MMX) vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_mmx;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_ssse3;
-    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_c;
-    if (flags & HAS_SSE2) vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_ssse3;
-    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_c;
-    if (flags & HAS_SSE2) vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_ssse3;
+  vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_c;
+  if (flags & HAS_SSE2)
+    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_ssse3;
+  vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_c;
+  if (flags & HAS_MMX)
+    vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_mmx;
+  vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_c;
+  if (flags & HAS_MMX)
+    vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_mmx;
+  vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_c;
+  if (flags & HAS_SSE2)
+    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_ssse3;
+  vp8_block_error = vp8_block_error_c;
+  if (flags & HAS_SSE2)
+    vp8_block_error = vp8_block_error_sse2;
+  vp8_copy32xn = vp8_copy32xn_c;
+  if (flags & HAS_SSE2)
+    vp8_copy32xn = vp8_copy32xn_sse2;
+  if (flags & HAS_SSE3)
+    vp8_copy32xn = vp8_copy32xn_sse3;
+  vp8_copy_mem16x16 = vp8_copy_mem16x16_c;
+  if (flags & HAS_SSE2)
+    vp8_copy_mem16x16 = vp8_copy_mem16x16_sse2;
+  vp8_copy_mem8x4 = vp8_copy_mem8x4_c;
+  if (flags & HAS_MMX)
+    vp8_copy_mem8x4 = vp8_copy_mem8x4_mmx;
+  vp8_copy_mem8x8 = vp8_copy_mem8x8_c;
+  if (flags & HAS_MMX)
+    vp8_copy_mem8x8 = vp8_copy_mem8x8_mmx;
+  vp8_dc_only_idct_add = vp8_dc_only_idct_add_c;
+  if (flags & HAS_MMX)
+    vp8_dc_only_idct_add = vp8_dc_only_idct_add_mmx;
+  vp8_denoiser_filter = vp8_denoiser_filter_c;
+  if (flags & HAS_SSE2)
+    vp8_denoiser_filter = vp8_denoiser_filter_sse2;
+  vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_c;
+  if (flags & HAS_SSE2)
+    vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_sse2;
+  vp8_dequant_idct_add = vp8_dequant_idct_add_c;
+  if (flags & HAS_MMX)
+    vp8_dequant_idct_add = vp8_dequant_idct_add_mmx;
+  vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_c;
+  if (flags & HAS_SSE2)
+    vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_sse2;
+  vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_c;
+  if (flags & HAS_SSE2)
+    vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_sse2;
+  vp8_dequantize_b = vp8_dequantize_b_c;
+  if (flags & HAS_MMX)
+    vp8_dequantize_b = vp8_dequantize_b_mmx;
+  vp8_diamond_search_sad = vp8_diamond_search_sad_c;
+  if (flags & HAS_SSE2)
+    vp8_diamond_search_sad = vp8_diamond_search_sadx4;
+  vp8_fast_quantize_b = vp8_fast_quantize_b_c;
+  if (flags & HAS_SSE2)
+    vp8_fast_quantize_b = vp8_fast_quantize_b_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_fast_quantize_b = vp8_fast_quantize_b_ssse3;
+  vp8_filter_by_weight16x16 = vp8_filter_by_weight16x16_c;
+  if (flags & HAS_SSE2)
+    vp8_filter_by_weight16x16 = vp8_filter_by_weight16x16_sse2;
+  vp8_filter_by_weight8x8 = vp8_filter_by_weight8x8_c;
+  if (flags & HAS_SSE2)
+    vp8_filter_by_weight8x8 = vp8_filter_by_weight8x8_sse2;
+  vp8_full_search_sad = vp8_full_search_sad_c;
+  if (flags & HAS_SSE3)
+    vp8_full_search_sad = vp8_full_search_sadx3;
+  if (flags & HAS_SSE4_1)
+    vp8_full_search_sad = vp8_full_search_sadx8;
+  vp8_loop_filter_bh = vp8_loop_filter_bh_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_bh = vp8_loop_filter_bh_sse2;
+  vp8_loop_filter_bv = vp8_loop_filter_bv_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_bv = vp8_loop_filter_bv_sse2;
+  vp8_loop_filter_mbh = vp8_loop_filter_mbh_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_mbh = vp8_loop_filter_mbh_sse2;
+  vp8_loop_filter_mbv = vp8_loop_filter_mbv_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_mbv = vp8_loop_filter_mbv_sse2;
+  vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_sse2;
+  vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_sse2;
+  vp8_loop_filter_simple_mbh = vp8_loop_filter_simple_horizontal_edge_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_simple_mbh = vp8_loop_filter_simple_horizontal_edge_sse2;
+  vp8_loop_filter_simple_mbv = vp8_loop_filter_simple_vertical_edge_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_simple_mbv = vp8_loop_filter_simple_vertical_edge_sse2;
+  vp8_mbblock_error = vp8_mbblock_error_c;
+  if (flags & HAS_SSE2)
+    vp8_mbblock_error = vp8_mbblock_error_sse2;
+  vp8_mbuverror = vp8_mbuverror_c;
+  if (flags & HAS_SSE2)
+    vp8_mbuverror = vp8_mbuverror_sse2;
+  vp8_refining_search_sad = vp8_refining_search_sad_c;
+  if (flags & HAS_SSE2)
+    vp8_refining_search_sad = vp8_refining_search_sadx4;
+  vp8_regular_quantize_b = vp8_regular_quantize_b_c;
+  if (flags & HAS_SSE2)
+    vp8_regular_quantize_b = vp8_regular_quantize_b_sse2;
+  if (flags & HAS_SSE4_1)
+    vp8_regular_quantize_b = vp8_regular_quantize_b_sse4_1;
+  vp8_short_fdct4x4 = vp8_short_fdct4x4_c;
+  if (flags & HAS_SSE2)
+    vp8_short_fdct4x4 = vp8_short_fdct4x4_sse2;
+  vp8_short_fdct8x4 = vp8_short_fdct8x4_c;
+  if (flags & HAS_SSE2)
+    vp8_short_fdct8x4 = vp8_short_fdct8x4_sse2;
+  vp8_short_idct4x4llm = vp8_short_idct4x4llm_c;
+  if (flags & HAS_MMX)
+    vp8_short_idct4x4llm = vp8_short_idct4x4llm_mmx;
+  vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_c;
+  if (flags & HAS_SSE2)
+    vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_sse2;
+  vp8_short_walsh4x4 = vp8_short_walsh4x4_c;
+  if (flags & HAS_SSE2)
+    vp8_short_walsh4x4 = vp8_short_walsh4x4_sse2;
+  vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_c;
+  if (flags & HAS_SSE2)
+    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_ssse3;
+  vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_c;
+  if (flags & HAS_MMX)
+    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_mmx;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_ssse3;
+  vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_c;
+  if (flags & HAS_SSE2)
+    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_ssse3;
+  vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_c;
+  if (flags & HAS_SSE2)
+    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_ssse3;
 }
 #endif
 

third_party/libvpx/source/config/linux/ia32/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/ia32/vp9_rtcd.h b/third_party/libvpx/source/config/linux/ia32/vp9_rtcd.h
index 2609a0d..33014a3 100644
--- a/third_party/libvpx/source/config/linux/ia32/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/linux/ia32/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,168 +30,519 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-int64_t vp9_block_error_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-int64_t vp9_block_error_avx2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-RTCD_EXTERN int64_t (*vp9_block_error)(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
+int64_t vp9_block_error_sse2(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             intptr_t block_size,
+                             int64_t* ssz);
+int64_t vp9_block_error_avx2(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             intptr_t block_size,
+                             int64_t* ssz);
+RTCD_EXTERN int64_t (*vp9_block_error)(const tran_low_t* coeff,
+                                       const tran_low_t* dqcoeff,
+                                       intptr_t block_size,
+                                       int64_t* ssz);
 
-int64_t vp9_block_error_fp_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
-int64_t vp9_block_error_fp_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
-RTCD_EXTERN int64_t (*vp9_block_error_fp)(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             int block_size);
+int64_t vp9_block_error_fp_sse2(const tran_low_t* coeff,
+                                const tran_low_t* dqcoeff,
+                                int block_size);
+RTCD_EXTERN int64_t (*vp9_block_error_fp)(const tran_low_t* coeff,
+                                          const tran_low_t* dqcoeff,
+                                          int block_size);
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-int vp9_denoiser_filter_sse2(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-RTCD_EXTERN int (*vp9_denoiser_filter)(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
+int vp9_denoiser_filter_sse2(const uint8_t* sig,
+                             int sig_stride,
+                             const uint8_t* mc_avg,
+                             int mc_avg_stride,
+                             uint8_t* avg,
+                             int avg_stride,
+                             int increase_denoising,
+                             BLOCK_SIZE bs,
+                             int motion_magnitude);
+RTCD_EXTERN int (*vp9_denoiser_filter)(const uint8_t* sig,
+                                       int sig_stride,
+                                       const uint8_t* mc_avg,
+                                       int mc_avg_stride,
+                                       uint8_t* avg,
+                                       int avg_stride,
+                                       int increase_denoising,
+                                       BLOCK_SIZE bs,
+                                       int motion_magnitude);
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
-int vp9_diamond_search_sad_avx(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
-RTCD_EXTERN int (*vp9_diamond_search_sad)(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
+int vp9_diamond_search_sad_avx(const struct macroblock* x,
+                               const struct search_site_config* cfg,
+                               struct mv* ref_mv,
+                               struct mv* best_mv,
+                               int search_param,
+                               int sad_per_bit,
+                               int* num00,
+                               const struct vp9_variance_vtable* fn_ptr,
+                               const struct mv* center_mv);
+RTCD_EXTERN int (*vp9_diamond_search_sad)(
+    const struct macroblock* x,
+    const struct search_site_config* cfg,
+    struct mv* ref_mv,
+    struct mv* best_mv,
+    int search_param,
+    int sad_per_bit,
+    int* num00,
+    const struct vp9_variance_vtable* fn_ptr,
+    const struct mv* center_mv);
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_fdct8x8_quant_ssse3(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_fdct8x8_quant)(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+void vp9_fdct8x8_quant_ssse3(const int16_t* input,
+                             int stride,
+                             tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+RTCD_EXTERN void (*vp9_fdct8x8_quant)(const int16_t* input,
+                                      int stride,
+                                      tran_low_t* coeff_ptr,
+                                      intptr_t n_coeffs,
+                                      int skip_block,
+                                      const int16_t* round_ptr,
+                                      const int16_t* quant_ptr,
+                                      tran_low_t* qcoeff_ptr,
+                                      tran_low_t* dqcoeff_ptr,
+                                      const int16_t* dequant_ptr,
+                                      uint16_t* eob_ptr,
+                                      const int16_t* scan,
+                                      const int16_t* iscan);
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht16x16_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_fht16x16)(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
+void vp9_fht16x16_sse2(const int16_t* input,
+                       tran_low_t* output,
+                       int stride,
+                       int tx_type);
+RTCD_EXTERN void (*vp9_fht16x16)(const int16_t* input,
+                                 tran_low_t* output,
+                                 int stride,
+                                 int tx_type);
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht4x4_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_fht4x4)(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
+void vp9_fht4x4_sse2(const int16_t* input,
+                     tran_low_t* output,
+                     int stride,
+                     int tx_type);
+RTCD_EXTERN void (*vp9_fht4x4)(const int16_t* input,
+                               tran_low_t* output,
+                               int stride,
+                               int tx_type);
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht8x8_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_fht8x8)(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
+void vp9_fht8x8_sse2(const int16_t* input,
+                     tran_low_t* output,
+                     int stride,
+                     int tx_type);
+RTCD_EXTERN void (*vp9_fht8x8)(const int16_t* input,
+                               tran_low_t* output,
+                               int stride,
+                               int tx_type);
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-void vp9_filter_by_weight16x16_sse2(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-RTCD_EXTERN void (*vp9_filter_by_weight16x16)(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
+void vp9_filter_by_weight16x16_sse2(const uint8_t* src,
+                                    int src_stride,
+                                    uint8_t* dst,
+                                    int dst_stride,
+                                    int src_weight);
+RTCD_EXTERN void (*vp9_filter_by_weight16x16)(const uint8_t* src,
+                                              int src_stride,
+                                              uint8_t* dst,
+                                              int dst_stride,
+                                              int src_weight);
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-void vp9_filter_by_weight8x8_sse2(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-RTCD_EXTERN void (*vp9_filter_by_weight8x8)(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
+void vp9_filter_by_weight8x8_sse2(const uint8_t* src,
+                                  int src_stride,
+                                  uint8_t* dst,
+                                  int dst_stride,
+                                  int src_weight);
+RTCD_EXTERN void (*vp9_filter_by_weight8x8)(const uint8_t* src,
+                                            int src_stride,
+                                            uint8_t* dst,
+                                            int dst_stride,
+                                            int src_weight);
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vp9_fwht4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vp9_fwht4x4)(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vp9_fwht4x4_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vp9_fwht4x4)(const int16_t* input,
+                                tran_low_t* output,
+                                int stride);
 
-int64_t vp9_highbd_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
-int64_t vp9_highbd_block_error_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
-RTCD_EXTERN int64_t (*vp9_highbd_block_error)(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
+int64_t vp9_highbd_block_error_c(const tran_low_t* coeff,
+                                 const tran_low_t* dqcoeff,
+                                 intptr_t block_size,
+                                 int64_t* ssz,
+                                 int bd);
+int64_t vp9_highbd_block_error_sse2(const tran_low_t* coeff,
+                                    const tran_low_t* dqcoeff,
+                                    intptr_t block_size,
+                                    int64_t* ssz,
+                                    int bd);
+RTCD_EXTERN int64_t (*vp9_highbd_block_error)(const tran_low_t* coeff,
+                                              const tran_low_t* dqcoeff,
+                                              intptr_t block_size,
+                                              int64_t* ssz,
+                                              int bd);
 
-void vp9_highbd_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht16x16_c(const int16_t* input,
+                           tran_low_t* output,
+                           int stride,
+                           int tx_type);
 #define vp9_highbd_fht16x16 vp9_highbd_fht16x16_c
 
-void vp9_highbd_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht4x4_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht4x4 vp9_highbd_fht4x4_c
 
-void vp9_highbd_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht8x8_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht8x8 vp9_highbd_fht8x8_c
 
-void vp9_highbd_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_highbd_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_highbd_fwht4x4 vp9_highbd_fwht4x4_c
 
-void vp9_highbd_iht16x16_256_add_c(const tran_low_t *input, uint16_t *output, int pitch, int tx_type, int bd);
+void vp9_highbd_iht16x16_256_add_c(const tran_low_t* input,
+                                   uint16_t* output,
+                                   int pitch,
+                                   int tx_type,
+                                   int bd);
 #define vp9_highbd_iht16x16_256_add vp9_highbd_iht16x16_256_add_c
 
-void vp9_highbd_iht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht4x4_16_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht4x4_16_add vp9_highbd_iht4x4_16_add_c
 
-void vp9_highbd_iht8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht8x8_64_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht8x8_64_add vp9_highbd_iht8x8_64_add_c
 
-void vp9_highbd_mbpost_proc_across_ip_c(uint16_t *src, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_across_ip_c(uint16_t* src,
+                                        int pitch,
+                                        int rows,
+                                        int cols,
+                                        int flimit);
 #define vp9_highbd_mbpost_proc_across_ip vp9_highbd_mbpost_proc_across_ip_c
 
-void vp9_highbd_mbpost_proc_down_c(uint16_t *dst, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_down_c(uint16_t* dst,
+                                   int pitch,
+                                   int rows,
+                                   int cols,
+                                   int flimit);
 #define vp9_highbd_mbpost_proc_down vp9_highbd_mbpost_proc_down_c
 
-void vp9_highbd_post_proc_down_and_across_c(const uint16_t *src_ptr, uint16_t *dst_ptr, int src_pixels_per_line, int dst_pixels_per_line, int rows, int cols, int flimit);
-#define vp9_highbd_post_proc_down_and_across vp9_highbd_post_proc_down_and_across_c
+void vp9_highbd_post_proc_down_and_across_c(const uint16_t* src_ptr,
+                                            uint16_t* dst_ptr,
+                                            int src_pixels_per_line,
+                                            int dst_pixels_per_line,
+                                            int rows,
+                                            int cols,
+                                            int flimit);
+#define vp9_highbd_post_proc_down_and_across \
+  vp9_highbd_post_proc_down_and_across_c
 
-void vp9_highbd_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_c(const tran_low_t* coeff_ptr,
+                              intptr_t n_coeffs,
+                              int skip_block,
+                              const int16_t* round_ptr,
+                              const int16_t* quant_ptr,
+                              tran_low_t* qcoeff_ptr,
+                              tran_low_t* dqcoeff_ptr,
+                              const int16_t* dequant_ptr,
+                              uint16_t* eob_ptr,
+                              const int16_t* scan,
+                              const int16_t* iscan);
 #define vp9_highbd_quantize_fp vp9_highbd_quantize_fp_c
 
-void vp9_highbd_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 #define vp9_highbd_quantize_fp_32x32 vp9_highbd_quantize_fp_32x32_c
 
-void vp9_highbd_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_highbd_temporal_filter_apply_c(const uint8_t* frame1,
+                                        unsigned int stride,
+                                        const uint8_t* frame2,
+                                        unsigned int block_width,
+                                        unsigned int block_height,
+                                        int strength,
+                                        int filter_weight,
+                                        uint32_t* accumulator,
+                                        uint16_t* count);
 #define vp9_highbd_temporal_filter_apply vp9_highbd_temporal_filter_apply_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
-void vp9_iht16x16_256_add_sse2(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
-RTCD_EXTERN void (*vp9_iht16x16_256_add)(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
+void vp9_iht16x16_256_add_sse2(const tran_low_t* input,
+                               uint8_t* output,
+                               int pitch,
+                               int tx_type);
+RTCD_EXTERN void (*vp9_iht16x16_256_add)(const tran_low_t* input,
+                                         uint8_t* output,
+                                         int pitch,
+                                         int tx_type);
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_iht4x4_16_add)(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht4x4_16_add_sse2(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
+RTCD_EXTERN void (*vp9_iht4x4_16_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride,
+                                      int tx_type);
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht8x8_64_add_sse2(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_iht8x8_64_add)(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht8x8_64_add_sse2(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
+RTCD_EXTERN void (*vp9_iht8x8_64_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride,
+                                      int tx_type);
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_quantize_fp)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
+void vp9_quantize_fp_sse2(const tran_low_t* coeff_ptr,
+                          intptr_t n_coeffs,
+                          int skip_block,
+                          const int16_t* round_ptr,
+                          const int16_t* quant_ptr,
+                          tran_low_t* qcoeff_ptr,
+                          tran_low_t* dqcoeff_ptr,
+                          const int16_t* dequant_ptr,
+                          uint16_t* eob_ptr,
+                          const int16_t* scan,
+                          const int16_t* iscan);
+RTCD_EXTERN void (*vp9_quantize_fp)(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vp9_quantize_fp_32x32 vp9_quantize_fp_32x32_c
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
-void vp9_scale_and_extend_frame_ssse3(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
-RTCD_EXTERN void (*vp9_scale_and_extend_frame)(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
+void vp9_scale_and_extend_frame_ssse3(const struct yv12_buffer_config* src,
+                                      struct yv12_buffer_config* dst,
+                                      INTERP_FILTER filter_type,
+                                      int phase_scaler);
+RTCD_EXTERN void (*vp9_scale_and_extend_frame)(
+    const struct yv12_buffer_config* src,
+    struct yv12_buffer_config* dst,
+    INTERP_FILTER filter_type,
+    int phase_scaler);
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
-void vp9_temporal_filter_apply_sse4_1(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
-RTCD_EXTERN void (*vp9_temporal_filter_apply)(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
+void vp9_temporal_filter_apply_sse4_1(const uint8_t* frame1,
+                                      unsigned int stride,
+                                      const uint8_t* frame2,
+                                      unsigned int block_width,
+                                      unsigned int block_height,
+                                      int strength,
+                                      int filter_weight,
+                                      uint32_t* accumulator,
+                                      uint16_t* count);
+RTCD_EXTERN void (*vp9_temporal_filter_apply)(const uint8_t* frame1,
+                                              unsigned int stride,
+                                              const uint8_t* frame2,
+                                              unsigned int block_width,
+                                              unsigned int block_height,
+                                              int strength,
+                                              int filter_weight,
+                                              uint32_t* accumulator,
+                                              uint16_t* count);
 
 void vp9_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vp9_block_error = vp9_block_error_c;
-    if (flags & HAS_SSE2) vp9_block_error = vp9_block_error_sse2;
-    if (flags & HAS_AVX2) vp9_block_error = vp9_block_error_avx2;
-    vp9_block_error_fp = vp9_block_error_fp_c;
-    if (flags & HAS_SSE2) vp9_block_error_fp = vp9_block_error_fp_sse2;
-    vp9_denoiser_filter = vp9_denoiser_filter_c;
-    if (flags & HAS_SSE2) vp9_denoiser_filter = vp9_denoiser_filter_sse2;
-    vp9_diamond_search_sad = vp9_diamond_search_sad_c;
-    if (flags & HAS_AVX) vp9_diamond_search_sad = vp9_diamond_search_sad_avx;
-    vp9_fdct8x8_quant = vp9_fdct8x8_quant_c;
-    if (flags & HAS_SSSE3) vp9_fdct8x8_quant = vp9_fdct8x8_quant_ssse3;
-    vp9_fht16x16 = vp9_fht16x16_c;
-    if (flags & HAS_SSE2) vp9_fht16x16 = vp9_fht16x16_sse2;
-    vp9_fht4x4 = vp9_fht4x4_c;
-    if (flags & HAS_SSE2) vp9_fht4x4 = vp9_fht4x4_sse2;
-    vp9_fht8x8 = vp9_fht8x8_c;
-    if (flags & HAS_SSE2) vp9_fht8x8 = vp9_fht8x8_sse2;
-    vp9_filter_by_weight16x16 = vp9_filter_by_weight16x16_c;
-    if (flags & HAS_SSE2) vp9_filter_by_weight16x16 = vp9_filter_by_weight16x16_sse2;
-    vp9_filter_by_weight8x8 = vp9_filter_by_weight8x8_c;
-    if (flags & HAS_SSE2) vp9_filter_by_weight8x8 = vp9_filter_by_weight8x8_sse2;
-    vp9_fwht4x4 = vp9_fwht4x4_c;
-    if (flags & HAS_SSE2) vp9_fwht4x4 = vp9_fwht4x4_sse2;
-    vp9_highbd_block_error = vp9_highbd_block_error_c;
-    if (flags & HAS_SSE2) vp9_highbd_block_error = vp9_highbd_block_error_sse2;
-    vp9_iht16x16_256_add = vp9_iht16x16_256_add_c;
-    if (flags & HAS_SSE2) vp9_iht16x16_256_add = vp9_iht16x16_256_add_sse2;
-    vp9_iht4x4_16_add = vp9_iht4x4_16_add_c;
-    if (flags & HAS_SSE2) vp9_iht4x4_16_add = vp9_iht4x4_16_add_sse2;
-    vp9_iht8x8_64_add = vp9_iht8x8_64_add_c;
-    if (flags & HAS_SSE2) vp9_iht8x8_64_add = vp9_iht8x8_64_add_sse2;
-    vp9_quantize_fp = vp9_quantize_fp_c;
-    if (flags & HAS_SSE2) vp9_quantize_fp = vp9_quantize_fp_sse2;
-    vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_c;
-    if (flags & HAS_SSSE3) vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_ssse3;
-    vp9_temporal_filter_apply = vp9_temporal_filter_apply_c;
-    if (flags & HAS_SSE4_1) vp9_temporal_filter_apply = vp9_temporal_filter_apply_sse4_1;
+  vp9_block_error = vp9_block_error_c;
+  if (flags & HAS_SSE2)
+    vp9_block_error = vp9_block_error_sse2;
+  if (flags & HAS_AVX2)
+    vp9_block_error = vp9_block_error_avx2;
+  vp9_block_error_fp = vp9_block_error_fp_c;
+  if (flags & HAS_SSE2)
+    vp9_block_error_fp = vp9_block_error_fp_sse2;
+  vp9_denoiser_filter = vp9_denoiser_filter_c;
+  if (flags & HAS_SSE2)
+    vp9_denoiser_filter = vp9_denoiser_filter_sse2;
+  vp9_diamond_search_sad = vp9_diamond_search_sad_c;
+  if (flags & HAS_AVX)
+    vp9_diamond_search_sad = vp9_diamond_search_sad_avx;
+  vp9_fdct8x8_quant = vp9_fdct8x8_quant_c;
+  if (flags & HAS_SSSE3)
+    vp9_fdct8x8_quant = vp9_fdct8x8_quant_ssse3;
+  vp9_fht16x16 = vp9_fht16x16_c;
+  if (flags & HAS_SSE2)
+    vp9_fht16x16 = vp9_fht16x16_sse2;
+  vp9_fht4x4 = vp9_fht4x4_c;
+  if (flags & HAS_SSE2)
+    vp9_fht4x4 = vp9_fht4x4_sse2;
+  vp9_fht8x8 = vp9_fht8x8_c;
+  if (flags & HAS_SSE2)
+    vp9_fht8x8 = vp9_fht8x8_sse2;
+  vp9_filter_by_weight16x16 = vp9_filter_by_weight16x16_c;
+  if (flags & HAS_SSE2)
+    vp9_filter_by_weight16x16 = vp9_filter_by_weight16x16_sse2;
+  vp9_filter_by_weight8x8 = vp9_filter_by_weight8x8_c;
+  if (flags & HAS_SSE2)
+    vp9_filter_by_weight8x8 = vp9_filter_by_weight8x8_sse2;
+  vp9_fwht4x4 = vp9_fwht4x4_c;
+  if (flags & HAS_SSE2)
+    vp9_fwht4x4 = vp9_fwht4x4_sse2;
+  vp9_highbd_block_error = vp9_highbd_block_error_c;
+  if (flags & HAS_SSE2)
+    vp9_highbd_block_error = vp9_highbd_block_error_sse2;
+  vp9_iht16x16_256_add = vp9_iht16x16_256_add_c;
+  if (flags & HAS_SSE2)
+    vp9_iht16x16_256_add = vp9_iht16x16_256_add_sse2;
+  vp9_iht4x4_16_add = vp9_iht4x4_16_add_c;
+  if (flags & HAS_SSE2)
+    vp9_iht4x4_16_add = vp9_iht4x4_16_add_sse2;
+  vp9_iht8x8_64_add = vp9_iht8x8_64_add_c;
+  if (flags & HAS_SSE2)
+    vp9_iht8x8_64_add = vp9_iht8x8_64_add_sse2;
+  vp9_quantize_fp = vp9_quantize_fp_c;
+  if (flags & HAS_SSE2)
+    vp9_quantize_fp = vp9_quantize_fp_sse2;
+  vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_c;
+  if (flags & HAS_SSSE3)
+    vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_ssse3;
+  vp9_temporal_filter_apply = vp9_temporal_filter_apply_c;
+  if (flags & HAS_SSE4_1)
+    vp9_temporal_filter_apply = vp9_temporal_filter_apply_sse4_1;
 }
 #endif
 

third_party/libvpx/source/config/linux/ia32/vpx_config.asm

diff --git a/third_party/libvpx/source/config/linux/ia32/vpx_config.asm b/third_party/libvpx/source/config/linux/ia32/vpx_config.asm
index f4375a0f..22d07d6 100644
--- a/third_party/libvpx/source/config/linux/ia32/vpx_config.asm
+++ b/third_party/libvpx/source/config/linux/ia32/vpx_config.asm
@@ -18,6 +18,7 @@
 %define HAVE_AVX 1
 %define HAVE_AVX2 1
 %define HAVE_VSX 0
+%define HAVE_MMI 0
 %define HAVE_VPX_PORTS 1
 %define HAVE_PTHREAD_H 1
 %define HAVE_UNISTD_H 0

third_party/libvpx/source/config/linux/ia32/vpx_config.h

diff --git a/third_party/libvpx/source/config/linux/ia32/vpx_config.h b/third_party/libvpx/source/config/linux/ia32/vpx_config.h
index 65d869f..5279532 100644
--- a/third_party/libvpx/source/config/linux/ia32/vpx_config.h
+++ b/third_party/libvpx/source/config/linux/ia32/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 1
 #define HAVE_AVX2 1
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/linux/ia32/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/ia32/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/linux/ia32/vpx_dsp_rtcd.h
index 58cad7f6..b463d4b37 100644
--- a/third_party/libvpx/source/config/linux/ia32/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/linux/ia32/vpx_dsp_rtcd.h
@@ -14,2807 +14,9640 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
-unsigned int vpx_avg_4x4_sse2(const uint8_t *, int p);
-RTCD_EXTERN unsigned int (*vpx_avg_4x4)(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
+unsigned int vpx_avg_4x4_sse2(const uint8_t*, int p);
+RTCD_EXTERN unsigned int (*vpx_avg_4x4)(const uint8_t*, int p);
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
-unsigned int vpx_avg_8x8_sse2(const uint8_t *, int p);
-RTCD_EXTERN unsigned int (*vpx_avg_8x8)(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
+unsigned int vpx_avg_8x8_sse2(const uint8_t*, int p);
+RTCD_EXTERN unsigned int (*vpx_avg_8x8)(const uint8_t*, int p);
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-void vpx_comp_avg_pred_sse2(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-RTCD_EXTERN void (*vpx_comp_avg_pred)(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
+void vpx_comp_avg_pred_sse2(uint8_t* comp_pred,
+                            const uint8_t* pred,
+                            int width,
+                            int height,
+                            const uint8_t* ref,
+                            int ref_stride);
+RTCD_EXTERN void (*vpx_comp_avg_pred)(uint8_t* comp_pred,
+                                      const uint8_t* pred,
+                                      int width,
+                                      int height,
+                                      const uint8_t* ref,
+                                      int ref_stride);
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_convolve8_sse2(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve8_ssse3(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avx2(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+RTCD_EXTERN void (*vpx_convolve8)(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avg_sse2(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
+void vpx_convolve8_avg_ssse3(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+RTCD_EXTERN void (*vpx_convolve8_avg)(const uint8_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h);
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg_horiz)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_avg_horiz_sse2(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
+void vpx_convolve8_avg_horiz_ssse3(const uint8_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h);
+RTCD_EXTERN void (*vpx_convolve8_avg_horiz)(const uint8_t* src,
+                                            ptrdiff_t src_stride,
+                                            uint8_t* dst,
+                                            ptrdiff_t dst_stride,
+                                            const int16_t* filter_x,
+                                            int x_step_q4,
+                                            const int16_t* filter_y,
+                                            int y_step_q4,
+                                            int w,
+                                            int h);
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg_vert)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_avg_vert_sse2(const uint8_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h);
+void vpx_convolve8_avg_vert_ssse3(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
+RTCD_EXTERN void (*vpx_convolve8_avg_vert)(const uint8_t* src,
+                                           ptrdiff_t src_stride,
+                                           uint8_t* dst,
+                                           ptrdiff_t dst_stride,
+                                           const int16_t* filter_x,
+                                           int x_step_q4,
+                                           const int16_t* filter_y,
+                                           int y_step_q4,
+                                           int w,
+                                           int h);
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_horiz)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+void vpx_convolve8_horiz_sse2(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_horiz_ssse3(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_horiz_avx2(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+RTCD_EXTERN void (*vpx_convolve8_horiz)(const uint8_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint8_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h);
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_vert)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
+void vpx_convolve8_vert_sse2(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+void vpx_convolve8_vert_ssse3(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_vert_avx2(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+RTCD_EXTERN void (*vpx_convolve8_vert)(const uint8_t* src,
+                                       ptrdiff_t src_stride,
+                                       uint8_t* dst,
+                                       ptrdiff_t dst_stride,
+                                       const int16_t* filter_x,
+                                       int x_step_q4,
+                                       const int16_t* filter_y,
+                                       int y_step_q4,
+                                       int w,
+                                       int h);
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_avg_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve_avg)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve_avg_sse2(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+RTCD_EXTERN void (*vpx_convolve_avg)(const uint8_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint8_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h);
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_copy_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve_copy)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve_copy_sse2(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
+RTCD_EXTERN void (*vpx_convolve_copy)(const uint8_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h);
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_c
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_c
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_c
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_c
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d153_predictor_16x16_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_16x16)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d153_predictor_32x32_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_32x32)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_4x4_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d153_predictor_4x4_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_4x4)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d153_predictor_8x8_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_8x8)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d207_predictor_16x16_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_16x16)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d207_predictor_32x32_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_32x32)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d207_predictor_4x4_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_4x4)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d207_predictor_8x8_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_8x8)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_16x16_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_16x16)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_32x32_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_32x32)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_4x4_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_4x4)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_8x8_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_8x8)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d63_predictor_16x16_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_16x16)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d63_predictor_32x32_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_32x32)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_4x4_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d63_predictor_4x4_ssse3(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_4x4)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d63_predictor_8x8_ssse3(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_8x8)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_16x16_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_16x16)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_32x32_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_32x32)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_4x4_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_4x4)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_8x8_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_8x8)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_16x16_sse2(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_16x16)(uint8_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint8_t* above,
+                                                const uint8_t* left);
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_32x32_sse2(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_32x32)(uint8_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint8_t* above,
+                                                const uint8_t* left);
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_4x4_sse2(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_4x4)(uint8_t* dst,
+                                              ptrdiff_t y_stride,
+                                              const uint8_t* above,
+                                              const uint8_t* left);
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_8x8_sse2(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_8x8)(uint8_t* dst,
+                                              ptrdiff_t y_stride,
+                                              const uint8_t* above,
+                                              const uint8_t* left);
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_16x16_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_16x16)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_32x32_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_32x32)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_4x4_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_4x4)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_8x8_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_8x8)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_16x16_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_16x16)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_32x32_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_32x32)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_4x4_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_4x4)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_8x8_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_8x8)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct16x16)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct16x16)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_1_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct16x16_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_1_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct16x16_1)(const int16_t* input,
+                                    tran_low_t* output,
+                                    int stride);
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct32x32)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct32x32)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_1_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct32x32_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_1_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct32x32_1)(const int16_t* input,
+                                    tran_low_t* output,
+                                    int stride);
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_rd_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct32x32_rd)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_rd_sse2(const int16_t* input,
+                           tran_low_t* output,
+                           int stride);
+RTCD_EXTERN void (*vpx_fdct32x32_rd)(const int16_t* input,
+                                     tran_low_t* output,
+                                     int stride);
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct4x4)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct4x4)(const int16_t* input,
+                                tran_low_t* output,
+                                int stride);
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_1_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct4x4_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_1_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct4x4_1)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct8x8)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct8x8)(const int16_t* input,
+                                tran_low_t* output,
+                                int stride);
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_1_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct8x8_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_1_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct8x8_1)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-RTCD_EXTERN void (*vpx_get16x16var)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
+void vpx_get16x16var_sse2(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
+void vpx_get16x16var_avx2(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
+RTCD_EXTERN void (*vpx_get16x16var)(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse,
+                                    int* sum);
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_c
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get8x8var_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-RTCD_EXTERN void (*vpx_get8x8var)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
+void vpx_get8x8var_sse2(const uint8_t* src_ptr,
+                        int source_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        unsigned int* sse,
+                        int* sum);
+RTCD_EXTERN void (*vpx_get8x8var)(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse,
+                                  int* sum);
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
-unsigned int vpx_get_mb_ss_sse2(const int16_t *);
-RTCD_EXTERN unsigned int (*vpx_get_mb_ss)(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
+unsigned int vpx_get_mb_ss_sse2(const int16_t*);
+RTCD_EXTERN unsigned int (*vpx_get_mb_ss)(const int16_t*);
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_16x16_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_16x16)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_32x32_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_32x32)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_4x4_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_4x4)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_8x8_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_8x8)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_16x16_sse2(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-RTCD_EXTERN void (*vpx_hadamard_16x16)(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          tran_low_t* coeff);
+void vpx_hadamard_16x16_sse2(const int16_t* src_diff,
+                             int src_stride,
+                             tran_low_t* coeff);
+RTCD_EXTERN void (*vpx_hadamard_16x16)(const int16_t* src_diff,
+                                       int src_stride,
+                                       tran_low_t* coeff);
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_8x8_sse2(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-RTCD_EXTERN void (*vpx_hadamard_8x8)(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        tran_low_t* coeff);
+void vpx_hadamard_8x8_sse2(const int16_t* src_diff,
+                           int src_stride,
+                           tran_low_t* coeff);
+RTCD_EXTERN void (*vpx_hadamard_8x8)(const int16_t* src_diff,
+                                     int src_stride,
+                                     tran_low_t* coeff);
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_highbd_10_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_10_get16x16var vpx_highbd_10_get16x16var_c
 
-void vpx_highbd_10_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_10_get8x8var vpx_highbd_10_get8x8var_c
 
-unsigned int vpx_highbd_10_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+unsigned int vpx_highbd_10_mse16x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_mse16x16)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   const uint8_t* ref_ptr,
+                                                   int recon_stride,
+                                                   unsigned int* sse);
 
-unsigned int vpx_highbd_10_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse16x8 vpx_highbd_10_mse16x8_c
 
-unsigned int vpx_highbd_10_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse8x16 vpx_highbd_10_mse8x16_c
 
-unsigned int vpx_highbd_10_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_mse8x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
+unsigned int vpx_highbd_10_mse8x8_sse2(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_mse8x8)(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 const uint8_t* ref_ptr,
+                                                 int recon_stride,
+                                                 unsigned int* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x4 vpx_highbd_10_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x4 \
+  vpx_highbd_10_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x8 vpx_highbd_10_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x8 \
+  vpx_highbd_10_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x4 vpx_highbd_10_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x4 \
+  vpx_highbd_10_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x8 vpx_highbd_10_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x8 \
+  vpx_highbd_10_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-unsigned int vpx_highbd_10_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x16)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x8)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x16)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x64)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x4 vpx_highbd_10_variance4x4_c
 
-unsigned int vpx_highbd_10_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x8 vpx_highbd_10_variance4x8_c
 
-unsigned int vpx_highbd_10_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance64x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance64x64)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance8x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_10_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance8x16)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance8x4 vpx_highbd_10_variance8x4_c
 
-unsigned int vpx_highbd_10_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance8x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_10_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance8x8)(const uint8_t* src_ptr,
+                                                      int source_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride,
+                                                      unsigned int* sse);
 
-void vpx_highbd_12_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_12_get16x16var vpx_highbd_12_get16x16var_c
 
-void vpx_highbd_12_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_12_get8x8var vpx_highbd_12_get8x8var_c
 
-unsigned int vpx_highbd_12_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+unsigned int vpx_highbd_12_mse16x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_mse16x16)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   const uint8_t* ref_ptr,
+                                                   int recon_stride,
+                                                   unsigned int* sse);
 
-unsigned int vpx_highbd_12_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse16x8 vpx_highbd_12_mse16x8_c
 
-unsigned int vpx_highbd_12_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse8x16 vpx_highbd_12_mse8x16_c
 
-unsigned int vpx_highbd_12_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_mse8x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
+unsigned int vpx_highbd_12_mse8x8_sse2(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_mse8x8)(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 const uint8_t* ref_ptr,
+                                                 int recon_stride,
+                                                 unsigned int* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x4 vpx_highbd_12_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x4 \
+  vpx_highbd_12_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x8 vpx_highbd_12_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x8 \
+  vpx_highbd_12_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x4 vpx_highbd_12_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x4 \
+  vpx_highbd_12_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x8 vpx_highbd_12_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x8 \
+  vpx_highbd_12_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-unsigned int vpx_highbd_12_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x16)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x8)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x16)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x64)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x4 vpx_highbd_12_variance4x4_c
 
-unsigned int vpx_highbd_12_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x8 vpx_highbd_12_variance4x8_c
 
-unsigned int vpx_highbd_12_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance64x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance64x64)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance8x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_12_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance8x16)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance8x4 vpx_highbd_12_variance8x4_c
 
-unsigned int vpx_highbd_12_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance8x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_12_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance8x8)(const uint8_t* src_ptr,
+                                                      int source_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride,
+                                                      unsigned int* sse);
 
-void vpx_highbd_8_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get16x16var_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse,
+                                int* sum);
 #define vpx_highbd_8_get16x16var vpx_highbd_8_get16x16var_c
 
-void vpx_highbd_8_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get8x8var_c(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              unsigned int* sse,
+                              int* sum);
 #define vpx_highbd_8_get8x8var vpx_highbd_8_get8x8var_c
 
-unsigned int vpx_highbd_8_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
+unsigned int vpx_highbd_8_mse16x16_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int recon_stride,
+                                        unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_mse16x16)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  const uint8_t* ref_ptr,
+                                                  int recon_stride,
+                                                  unsigned int* sse);
 
-unsigned int vpx_highbd_8_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse16x8 vpx_highbd_8_mse16x8_c
 
-unsigned int vpx_highbd_8_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x16_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse8x16 vpx_highbd_8_mse8x16_c
 
-unsigned int vpx_highbd_8_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_mse8x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x8_c(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int recon_stride,
+                                   unsigned int* sse);
+unsigned int vpx_highbd_8_mse8x8_sse2(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_mse8x8)(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                const uint8_t* ref_ptr,
+                                                int recon_stride,
+                                                unsigned int* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x4 vpx_highbd_8_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x4 \
+  vpx_highbd_8_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x8 vpx_highbd_8_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x8 \
+  vpx_highbd_8_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x4 vpx_highbd_8_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x8 vpx_highbd_8_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-unsigned int vpx_highbd_8_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x16)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x32)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x8)(const uint8_t* src_ptr,
+                                                      int source_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride,
+                                                      unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x16)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x32)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x64_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x64)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x4 vpx_highbd_8_variance4x4_c
 
-unsigned int vpx_highbd_8_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x8 vpx_highbd_8_variance4x8_c
 
-unsigned int vpx_highbd_8_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance64x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance64x32)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance64x64_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance64x64)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance8x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x16_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_8_variance8x16_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance8x16)(const uint8_t* src_ptr,
+                                                      int source_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride,
+                                                      unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance8x4 vpx_highbd_8_variance8x4_c
 
-unsigned int vpx_highbd_8_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance8x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
+unsigned int vpx_highbd_8_variance8x8_sse2(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance8x8)(const uint8_t* src_ptr,
+                                                     int source_stride,
+                                                     const uint8_t* ref_ptr,
+                                                     int ref_stride,
+                                                     unsigned int* sse);
 
-unsigned int vpx_highbd_avg_4x4_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_4x4_c(const uint8_t*, int p);
 #define vpx_highbd_avg_4x4 vpx_highbd_avg_4x4_c
 
-unsigned int vpx_highbd_avg_8x8_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_8x8_c(const uint8_t*, int p);
 #define vpx_highbd_avg_8x8 vpx_highbd_avg_8x8_c
 
-void vpx_highbd_comp_avg_pred_c(uint16_t *comp_pred, const uint8_t *pred8, int width, int height, const uint8_t *ref8, int ref_stride);
+void vpx_highbd_comp_avg_pred_c(uint16_t* comp_pred,
+                                const uint8_t* pred8,
+                                int width,
+                                int height,
+                                const uint8_t* ref8,
+                                int ref_stride);
 #define vpx_highbd_comp_avg_pred vpx_highbd_comp_avg_pred_c
 
-void vpx_highbd_convolve8_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_c(const uint16_t* src,
+                            ptrdiff_t src_stride,
+                            uint16_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h,
+                            int bps);
+void vpx_highbd_convolve8_avx2(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8)(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
 
-void vpx_highbd_convolve8_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
+void vpx_highbd_convolve8_avg_avx2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg)(const uint16_t* src,
+                                             ptrdiff_t src_stride,
+                                             uint16_t* dst,
+                                             ptrdiff_t dst_stride,
+                                             const int16_t* filter_x,
+                                             int x_step_q4,
+                                             const int16_t* filter_y,
+                                             int y_step_q4,
+                                             int w,
+                                             int h,
+                                             int bps);
 
-void vpx_highbd_convolve8_avg_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_horiz_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg_horiz)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_horiz_c(const uint16_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint16_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h,
+                                      int bps);
+void vpx_highbd_convolve8_avg_horiz_avx2(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg_horiz)(const uint16_t* src,
+                                                   ptrdiff_t src_stride,
+                                                   uint16_t* dst,
+                                                   ptrdiff_t dst_stride,
+                                                   const int16_t* filter_x,
+                                                   int x_step_q4,
+                                                   const int16_t* filter_y,
+                                                   int y_step_q4,
+                                                   int w,
+                                                   int h,
+                                                   int bps);
 
-void vpx_highbd_convolve8_avg_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_vert_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg_vert)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_vert_c(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+void vpx_highbd_convolve8_avg_vert_avx2(const uint16_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint16_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h,
+                                        int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg_vert)(const uint16_t* src,
+                                                  ptrdiff_t src_stride,
+                                                  uint16_t* dst,
+                                                  ptrdiff_t dst_stride,
+                                                  const int16_t* filter_x,
+                                                  int x_step_q4,
+                                                  const int16_t* filter_y,
+                                                  int y_step_q4,
+                                                  int w,
+                                                  int h,
+                                                  int bps);
 
-void vpx_highbd_convolve8_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_horiz_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_horiz)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_horiz_c(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+void vpx_highbd_convolve8_horiz_avx2(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_horiz)(const uint16_t* src,
+                                               ptrdiff_t src_stride,
+                                               uint16_t* dst,
+                                               ptrdiff_t dst_stride,
+                                               const int16_t* filter_x,
+                                               int x_step_q4,
+                                               const int16_t* filter_y,
+                                               int y_step_q4,
+                                               int w,
+                                               int h,
+                                               int bps);
 
-void vpx_highbd_convolve8_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_vert_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_vert)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_vert_c(const uint16_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint16_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h,
+                                 int bps);
+void vpx_highbd_convolve8_vert_avx2(const uint16_t* src,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst,
+                                    ptrdiff_t dst_stride,
+                                    const int16_t* filter_x,
+                                    int x_step_q4,
+                                    const int16_t* filter_y,
+                                    int y_step_q4,
+                                    int w,
+                                    int h,
+                                    int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_vert)(const uint16_t* src,
+                                              ptrdiff_t src_stride,
+                                              uint16_t* dst,
+                                              ptrdiff_t dst_stride,
+                                              const int16_t* filter_x,
+                                              int x_step_q4,
+                                              const int16_t* filter_y,
+                                              int y_step_q4,
+                                              int w,
+                                              int h,
+                                              int bps);
 
-void vpx_highbd_convolve_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_avg_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_avg_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve_avg)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_avg_c(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+void vpx_highbd_convolve_avg_sse2(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+void vpx_highbd_convolve_avg_avx2(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve_avg)(const uint16_t* src,
+                                            ptrdiff_t src_stride,
+                                            uint16_t* dst,
+                                            ptrdiff_t dst_stride,
+                                            const int16_t* filter_x,
+                                            int x_step_q4,
+                                            const int16_t* filter_y,
+                                            int y_step_q4,
+                                            int w,
+                                            int h,
+                                            int bps);
 
-void vpx_highbd_convolve_copy_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_copy_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_copy_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve_copy)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_copy_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
+void vpx_highbd_convolve_copy_sse2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+void vpx_highbd_convolve_copy_avx2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve_copy)(const uint16_t* src,
+                                             ptrdiff_t src_stride,
+                                             uint16_t* dst,
+                                             ptrdiff_t dst_stride,
+                                             const int16_t* filter_x,
+                                             int x_step_q4,
+                                             const int16_t* filter_y,
+                                             int y_step_q4,
+                                             int w,
+                                             int h,
+                                             int bps);
 
-void vpx_highbd_d117_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_16x16 vpx_highbd_d117_predictor_16x16_c
 
-void vpx_highbd_d117_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_32x32 vpx_highbd_d117_predictor_32x32_c
 
-void vpx_highbd_d117_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_4x4 vpx_highbd_d117_predictor_4x4_c
 
-void vpx_highbd_d117_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_8x8 vpx_highbd_d117_predictor_8x8_c
 
-void vpx_highbd_d135_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_16x16 vpx_highbd_d135_predictor_16x16_c
 
-void vpx_highbd_d135_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_32x32 vpx_highbd_d135_predictor_32x32_c
 
-void vpx_highbd_d135_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_4x4 vpx_highbd_d135_predictor_4x4_c
 
-void vpx_highbd_d135_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_8x8 vpx_highbd_d135_predictor_8x8_c
 
-void vpx_highbd_d153_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_16x16 vpx_highbd_d153_predictor_16x16_c
 
-void vpx_highbd_d153_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_32x32 vpx_highbd_d153_predictor_32x32_c
 
-void vpx_highbd_d153_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_4x4 vpx_highbd_d153_predictor_4x4_c
 
-void vpx_highbd_d153_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_8x8 vpx_highbd_d153_predictor_8x8_c
 
-void vpx_highbd_d207_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_16x16 vpx_highbd_d207_predictor_16x16_c
 
-void vpx_highbd_d207_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_32x32 vpx_highbd_d207_predictor_32x32_c
 
-void vpx_highbd_d207_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_4x4 vpx_highbd_d207_predictor_4x4_c
 
-void vpx_highbd_d207_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_8x8 vpx_highbd_d207_predictor_8x8_c
 
-void vpx_highbd_d45_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_16x16 vpx_highbd_d45_predictor_16x16_c
 
-void vpx_highbd_d45_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_32x32 vpx_highbd_d45_predictor_32x32_c
 
-void vpx_highbd_d45_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_4x4 vpx_highbd_d45_predictor_4x4_c
 
-void vpx_highbd_d45_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_8x8 vpx_highbd_d45_predictor_8x8_c
 
-void vpx_highbd_d63_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_16x16 vpx_highbd_d63_predictor_16x16_c
 
-void vpx_highbd_d63_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_32x32 vpx_highbd_d63_predictor_32x32_c
 
-void vpx_highbd_d63_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_4x4 vpx_highbd_d63_predictor_4x4_c
 
-void vpx_highbd_d63_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_8x8 vpx_highbd_d63_predictor_8x8_c
 
-void vpx_highbd_dc_128_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_16x16 vpx_highbd_dc_128_predictor_16x16_c
 
-void vpx_highbd_dc_128_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_32x32 vpx_highbd_dc_128_predictor_32x32_c
 
-void vpx_highbd_dc_128_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_4x4 vpx_highbd_dc_128_predictor_4x4_c
 
-void vpx_highbd_dc_128_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_8x8 vpx_highbd_dc_128_predictor_8x8_c
 
-void vpx_highbd_dc_left_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_16x16_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_16x16 vpx_highbd_dc_left_predictor_16x16_c
 
-void vpx_highbd_dc_left_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_32x32_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_32x32 vpx_highbd_dc_left_predictor_32x32_c
 
-void vpx_highbd_dc_left_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_4x4_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_4x4 vpx_highbd_dc_left_predictor_4x4_c
 
-void vpx_highbd_dc_left_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_8x8_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_8x8 vpx_highbd_dc_left_predictor_8x8_c
 
-void vpx_highbd_dc_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_dc_predictor_16x16)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_dc_predictor_16x16_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
+RTCD_EXTERN void (*vpx_highbd_dc_predictor_16x16)(uint16_t* dst,
+                                                  ptrdiff_t y_stride,
+                                                  const uint16_t* above,
+                                                  const uint16_t* left,
+                                                  int bd);
 
-void vpx_highbd_dc_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_dc_predictor_32x32)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_dc_predictor_32x32_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
+RTCD_EXTERN void (*vpx_highbd_dc_predictor_32x32)(uint16_t* dst,
+                                                  ptrdiff_t y_stride,
+                                                  const uint16_t* above,
+                                                  const uint16_t* left,
+                                                  int bd);
 
-void vpx_highbd_dc_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_dc_predictor_4x4)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_dc_predictor_4x4_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_dc_predictor_4x4)(uint16_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint16_t* above,
+                                                const uint16_t* left,
+                                                int bd);
 
-void vpx_highbd_dc_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_dc_predictor_8x8)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_dc_predictor_8x8_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_dc_predictor_8x8)(uint16_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint16_t* above,
+                                                const uint16_t* left,
+                                                int bd);
 
-void vpx_highbd_dc_top_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_16x16 vpx_highbd_dc_top_predictor_16x16_c
 
-void vpx_highbd_dc_top_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_32x32 vpx_highbd_dc_top_predictor_32x32_c
 
-void vpx_highbd_dc_top_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_4x4 vpx_highbd_dc_top_predictor_4x4_c
 
-void vpx_highbd_dc_top_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_8x8 vpx_highbd_dc_top_predictor_8x8_c
 
-void vpx_highbd_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct16x16_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct16x16)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
+void vpx_highbd_fdct16x16_sse2(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct16x16)(const int16_t* input,
+                                         tran_low_t* output,
+                                         int stride);
 
-void vpx_highbd_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct16x16_1 vpx_highbd_fdct16x16_1_c
 
-void vpx_highbd_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct32x32_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct32x32)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
+void vpx_highbd_fdct32x32_sse2(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct32x32)(const int16_t* input,
+                                         tran_low_t* output,
+                                         int stride);
 
-void vpx_highbd_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct32x32_1 vpx_highbd_fdct32x32_1_c
 
-void vpx_highbd_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct32x32_rd_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct32x32_rd)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_rd_c(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
+void vpx_highbd_fdct32x32_rd_sse2(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct32x32_rd)(const int16_t* input,
+                                            tran_low_t* output,
+                                            int stride);
 
-void vpx_highbd_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct4x4)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_highbd_fdct4x4_sse2(const int16_t* input,
+                             tran_low_t* output,
+                             int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct4x4)(const int16_t* input,
+                                       tran_low_t* output,
+                                       int stride);
 
-void vpx_highbd_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct8x8_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct8x8)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_highbd_fdct8x8_sse2(const int16_t* input,
+                             tran_low_t* output,
+                             int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct8x8)(const int16_t* input,
+                                       tran_low_t* output,
+                                       int stride);
 
-void vpx_highbd_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_1_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
 #define vpx_highbd_fdct8x8_1 vpx_highbd_fdct8x8_1_c
 
-void vpx_highbd_h_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_16x16 vpx_highbd_h_predictor_16x16_c
 
-void vpx_highbd_h_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_32x32 vpx_highbd_h_predictor_32x32_c
 
-void vpx_highbd_h_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_4x4 vpx_highbd_h_predictor_4x4_c
 
-void vpx_highbd_h_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_8x8 vpx_highbd_h_predictor_8x8_c
 
-void vpx_highbd_idct16x16_10_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_10_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct16x16_10_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_10_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+void vpx_highbd_idct16x16_10_add_sse2(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct16x16_10_add)(const tran_low_t* input,
+                                                uint16_t* dest,
+                                                int stride,
+                                                int bd);
 
-void vpx_highbd_idct16x16_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct16x16_1_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
+void vpx_highbd_idct16x16_1_add_sse2(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_idct16x16_1_add)(const tran_low_t* input,
+                                               uint16_t* dest,
+                                               int stride,
+                                               int bd);
 
-void vpx_highbd_idct16x16_256_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct16x16_256_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_256_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t* input,
+                                       uint16_t* dest,
+                                       int stride,
+                                       int bd);
+RTCD_EXTERN void (*vpx_highbd_idct16x16_256_add)(const tran_low_t* input,
+                                                 uint16_t* dest,
+                                                 int stride,
+                                                 int bd);
 
-void vpx_highbd_idct16x16_38_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct16x16_38_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_38_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+void vpx_highbd_idct16x16_38_add_sse2(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct16x16_38_add)(const tran_low_t* input,
+                                                uint16_t* dest,
+                                                int stride,
+                                                int bd);
 
-void vpx_highbd_idct32x32_1024_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1024_add_c(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
 #define vpx_highbd_idct32x32_1024_add vpx_highbd_idct32x32_1024_add_c
 
-void vpx_highbd_idct32x32_135_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_135_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
 #define vpx_highbd_idct32x32_135_add vpx_highbd_idct32x32_135_add_c
 
-void vpx_highbd_idct32x32_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct32x32_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct32x32_1_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
+void vpx_highbd_idct32x32_1_add_sse2(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_idct32x32_1_add)(const tran_low_t* input,
+                                               uint16_t* dest,
+                                               int stride,
+                                               int bd);
 
-void vpx_highbd_idct32x32_34_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_34_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct32x32_34_add vpx_highbd_idct32x32_34_add_c
 
-void vpx_highbd_idct4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_16_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_16_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct4x4_16_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct4x4_16_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct4x4_16_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct4x4_16_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_idct4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct4x4_1_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
+void vpx_highbd_idct4x4_1_add_sse2(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+RTCD_EXTERN void (*vpx_highbd_idct4x4_1_add)(const tran_low_t* input,
+                                             uint16_t* dest,
+                                             int stride,
+                                             int bd);
 
-void vpx_highbd_idct8x8_12_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_12_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_12_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_12_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_12_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct8x8_12_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct8x8_12_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_12_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_idct8x8_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_1_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
+void vpx_highbd_idct8x8_1_add_sse2(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_1_add)(const tran_low_t* input,
+                                             uint16_t* dest,
+                                             int stride,
+                                             int bd);
 
-void vpx_highbd_idct8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_64_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_64_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_64_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_64_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct8x8_64_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct8x8_64_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_64_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_iwht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
 #define vpx_highbd_iwht4x4_16_add vpx_highbd_iwht4x4_16_add_c
 
-void vpx_highbd_iwht4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
 #define vpx_highbd_iwht4x4_1_add vpx_highbd_iwht4x4_1_add_c
 
-void vpx_highbd_lpf_horizontal_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_16_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_16)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_c(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
+void vpx_highbd_lpf_horizontal_16_sse2(uint16_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh,
+                                       int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_16)(uint16_t* s,
+                                                 int pitch,
+                                                 const uint8_t* blimit,
+                                                 const uint8_t* limit,
+                                                 const uint8_t* thresh,
+                                                 int bd);
 
-void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_16_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_16_dual)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh,
+                                         int bd);
+void vpx_highbd_lpf_horizontal_16_dual_sse2(uint16_t* s,
+                                            int pitch,
+                                            const uint8_t* blimit,
+                                            const uint8_t* limit,
+                                            const uint8_t* thresh,
+                                            int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_16_dual)(uint16_t* s,
+                                                      int pitch,
+                                                      const uint8_t* blimit,
+                                                      const uint8_t* limit,
+                                                      const uint8_t* thresh,
+                                                      int bd);
 
-void vpx_highbd_lpf_horizontal_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_4_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_4)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_4_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
+void vpx_highbd_lpf_horizontal_4_sse2(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit,
+                                      const uint8_t* limit,
+                                      const uint8_t* thresh,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_4)(uint16_t* s,
+                                                int pitch,
+                                                const uint8_t* blimit,
+                                                const uint8_t* limit,
+                                                const uint8_t* thresh,
+                                                int bd);
 
-void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_horizontal_4_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_4_dual)(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
+void vpx_highbd_lpf_horizontal_4_dual_sse2(uint16_t* s,
+                                           int pitch,
+                                           const uint8_t* blimit0,
+                                           const uint8_t* limit0,
+                                           const uint8_t* thresh0,
+                                           const uint8_t* blimit1,
+                                           const uint8_t* limit1,
+                                           const uint8_t* thresh1,
+                                           int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_4_dual)(uint16_t* s,
+                                                     int pitch,
+                                                     const uint8_t* blimit0,
+                                                     const uint8_t* limit0,
+                                                     const uint8_t* thresh0,
+                                                     const uint8_t* blimit1,
+                                                     const uint8_t* limit1,
+                                                     const uint8_t* thresh1,
+                                                     int bd);
 
-void vpx_highbd_lpf_horizontal_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_8_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_8)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_8_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
+void vpx_highbd_lpf_horizontal_8_sse2(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit,
+                                      const uint8_t* limit,
+                                      const uint8_t* thresh,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_8)(uint16_t* s,
+                                                int pitch,
+                                                const uint8_t* blimit,
+                                                const uint8_t* limit,
+                                                const uint8_t* thresh,
+                                                int bd);
 
-void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_horizontal_8_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_8_dual)(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
+void vpx_highbd_lpf_horizontal_8_dual_sse2(uint16_t* s,
+                                           int pitch,
+                                           const uint8_t* blimit0,
+                                           const uint8_t* limit0,
+                                           const uint8_t* thresh0,
+                                           const uint8_t* blimit1,
+                                           const uint8_t* limit1,
+                                           const uint8_t* thresh1,
+                                           int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_8_dual)(uint16_t* s,
+                                                     int pitch,
+                                                     const uint8_t* blimit0,
+                                                     const uint8_t* limit0,
+                                                     const uint8_t* thresh0,
+                                                     const uint8_t* blimit1,
+                                                     const uint8_t* limit1,
+                                                     const uint8_t* thresh1,
+                                                     int bd);
 
-void vpx_highbd_lpf_vertical_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_16_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_16)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_c(uint16_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh,
+                                  int bd);
+void vpx_highbd_lpf_vertical_16_sse2(uint16_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_16)(uint16_t* s,
+                                               int pitch,
+                                               const uint8_t* blimit,
+                                               const uint8_t* limit,
+                                               const uint8_t* thresh,
+                                               int bd);
 
-void vpx_highbd_lpf_vertical_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_16_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_16_dual)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_dual_c(uint16_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh,
+                                       int bd);
+void vpx_highbd_lpf_vertical_16_dual_sse2(uint16_t* s,
+                                          int pitch,
+                                          const uint8_t* blimit,
+                                          const uint8_t* limit,
+                                          const uint8_t* thresh,
+                                          int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_16_dual)(uint16_t* s,
+                                                    int pitch,
+                                                    const uint8_t* blimit,
+                                                    const uint8_t* limit,
+                                                    const uint8_t* thresh,
+                                                    int bd);
 
-void vpx_highbd_lpf_vertical_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_4_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_4)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_4_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
+void vpx_highbd_lpf_vertical_4_sse2(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_4)(uint16_t* s,
+                                              int pitch,
+                                              const uint8_t* blimit,
+                                              const uint8_t* limit,
+                                              const uint8_t* thresh,
+                                              int bd);
 
-void vpx_highbd_lpf_vertical_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_vertical_4_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_4_dual)(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_4_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
+void vpx_highbd_lpf_vertical_4_dual_sse2(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit0,
+                                         const uint8_t* limit0,
+                                         const uint8_t* thresh0,
+                                         const uint8_t* blimit1,
+                                         const uint8_t* limit1,
+                                         const uint8_t* thresh1,
+                                         int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_4_dual)(uint16_t* s,
+                                                   int pitch,
+                                                   const uint8_t* blimit0,
+                                                   const uint8_t* limit0,
+                                                   const uint8_t* thresh0,
+                                                   const uint8_t* blimit1,
+                                                   const uint8_t* limit1,
+                                                   const uint8_t* thresh1,
+                                                   int bd);
 
-void vpx_highbd_lpf_vertical_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_8_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_8)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_8_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
+void vpx_highbd_lpf_vertical_8_sse2(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_8)(uint16_t* s,
+                                              int pitch,
+                                              const uint8_t* blimit,
+                                              const uint8_t* limit,
+                                              const uint8_t* thresh,
+                                              int bd);
 
-void vpx_highbd_lpf_vertical_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_vertical_8_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_8_dual)(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_8_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
+void vpx_highbd_lpf_vertical_8_dual_sse2(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit0,
+                                         const uint8_t* limit0,
+                                         const uint8_t* thresh0,
+                                         const uint8_t* blimit1,
+                                         const uint8_t* limit1,
+                                         const uint8_t* thresh1,
+                                         int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_8_dual)(uint16_t* s,
+                                                   int pitch,
+                                                   const uint8_t* blimit0,
+                                                   const uint8_t* limit0,
+                                                   const uint8_t* thresh0,
+                                                   const uint8_t* blimit1,
+                                                   const uint8_t* limit1,
+                                                   const uint8_t* thresh1,
+                                                   int bd);
 
-void vpx_highbd_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_highbd_minmax_8x8_c(const uint8_t* s,
+                             int p,
+                             const uint8_t* d,
+                             int dp,
+                             int* min,
+                             int* max);
 #define vpx_highbd_minmax_8x8 vpx_highbd_minmax_8x8_c
 
-void vpx_highbd_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_highbd_quantize_b_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_highbd_quantize_b)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* zbin_ptr,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             const int16_t* quant_shift_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+void vpx_highbd_quantize_b_sse2(const tran_low_t* coeff_ptr,
+                                intptr_t n_coeffs,
+                                int skip_block,
+                                const int16_t* zbin_ptr,
+                                const int16_t* round_ptr,
+                                const int16_t* quant_ptr,
+                                const int16_t* quant_shift_ptr,
+                                tran_low_t* qcoeff_ptr,
+                                tran_low_t* dqcoeff_ptr,
+                                const int16_t* dequant_ptr,
+                                uint16_t* eob_ptr,
+                                const int16_t* scan,
+                                const int16_t* iscan);
+RTCD_EXTERN void (*vpx_highbd_quantize_b)(const tran_low_t* coeff_ptr,
+                                          intptr_t n_coeffs,
+                                          int skip_block,
+                                          const int16_t* zbin_ptr,
+                                          const int16_t* round_ptr,
+                                          const int16_t* quant_ptr,
+                                          const int16_t* quant_shift_ptr,
+                                          tran_low_t* qcoeff_ptr,
+                                          tran_low_t* dqcoeff_ptr,
+                                          const int16_t* dequant_ptr,
+                                          uint16_t* eob_ptr,
+                                          const int16_t* scan,
+                                          const int16_t* iscan);
 
-void vpx_highbd_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_highbd_quantize_b_32x32_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_highbd_quantize_b_32x32)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
+void vpx_highbd_quantize_b_32x32_sse2(const tran_low_t* coeff_ptr,
+                                      intptr_t n_coeffs,
+                                      int skip_block,
+                                      const int16_t* zbin_ptr,
+                                      const int16_t* round_ptr,
+                                      const int16_t* quant_ptr,
+                                      const int16_t* quant_shift_ptr,
+                                      tran_low_t* qcoeff_ptr,
+                                      tran_low_t* dqcoeff_ptr,
+                                      const int16_t* dequant_ptr,
+                                      uint16_t* eob_ptr,
+                                      const int16_t* scan,
+                                      const int16_t* iscan);
+RTCD_EXTERN void (*vpx_highbd_quantize_b_32x32)(const tran_low_t* coeff_ptr,
+                                                intptr_t n_coeffs,
+                                                int skip_block,
+                                                const int16_t* zbin_ptr,
+                                                const int16_t* round_ptr,
+                                                const int16_t* quant_ptr,
+                                                const int16_t* quant_shift_ptr,
+                                                tran_low_t* qcoeff_ptr,
+                                                tran_low_t* dqcoeff_ptr,
+                                                const int16_t* dequant_ptr,
+                                                uint16_t* eob_ptr,
+                                                const int16_t* scan,
+                                                const int16_t* iscan);
 
-unsigned int vpx_highbd_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad16x16_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x16)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x16_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x16_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad16x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad16x16x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad16x16x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad16x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x32)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x32_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad16x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad16x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad16x32x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x8_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int vpx_highbd_sad16x8_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x8)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
 
-unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x8_avg_sse2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x8_avg)(const uint8_t* src_ptr,
+                                                   int src_stride,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   const uint8_t* second_pred);
 
-void vpx_highbd_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad16x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x8x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void vpx_highbd_sad16x8x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad16x8x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x16_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x16)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x16_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x16_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad32x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x16x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad32x16x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x32)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x32_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad32x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad32x32x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x64)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x64_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x64_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad32x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad32x64x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x4 vpx_highbd_sad4x4_c
 
-unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x4_avg vpx_highbd_sad4x4_avg_c
 
-void vpx_highbd_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad4x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad4x4x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad4x4x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad4x4x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x8 vpx_highbd_sad4x8_c
 
-unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x8_avg vpx_highbd_sad4x8_avg_c
 
-void vpx_highbd_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad4x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad4x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad4x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad4x8x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad64x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad64x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad64x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad64x32)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad64x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad64x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad64x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad64x32_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad64x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad64x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad64x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad64x32x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad64x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad64x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad64x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad64x64)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad64x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad64x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad64x64_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad64x64_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad64x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad64x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad64x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad64x64x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int vpx_highbd_sad8x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x16)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
 
-unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x16_avg_sse2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x16_avg)(const uint8_t* src_ptr,
+                                                   int src_stride,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   const uint8_t* second_pred);
 
-void vpx_highbd_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad8x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void vpx_highbd_sad8x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad8x16x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x4)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int vpx_highbd_sad8x4_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x4)(const uint8_t* src_ptr,
+                                              int src_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride);
 
-unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x4_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x4_avg_sse2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x4_avg)(const uint8_t* src_ptr,
+                                                  int src_stride,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  const uint8_t* second_pred);
 
-void vpx_highbd_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad8x4x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad8x4x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad8x4x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int vpx_highbd_sad8x8_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x8)(const uint8_t* src_ptr,
+                                              int src_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride);
 
-unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x8_avg_sse2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x8_avg)(const uint8_t* src_ptr,
+                                                  int src_stride,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  const uint8_t* second_pred);
 
-void vpx_highbd_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad8x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad8x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad8x8x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
 
-void vpx_highbd_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride, int bd);
+void vpx_highbd_subtract_block_c(int rows,
+                                 int cols,
+                                 int16_t* diff_ptr,
+                                 ptrdiff_t diff_stride,
+                                 const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 const uint8_t* pred_ptr,
+                                 ptrdiff_t pred_stride,
+                                 int bd);
 #define vpx_highbd_subtract_block vpx_highbd_subtract_block_c
 
-void vpx_highbd_tm_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_tm_predictor_16x16)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_tm_predictor_16x16_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
+RTCD_EXTERN void (*vpx_highbd_tm_predictor_16x16)(uint16_t* dst,
+                                                  ptrdiff_t y_stride,
+                                                  const uint16_t* above,
+                                                  const uint16_t* left,
+                                                  int bd);
 
-void vpx_highbd_tm_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_tm_predictor_32x32)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_tm_predictor_32x32_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
+RTCD_EXTERN void (*vpx_highbd_tm_predictor_32x32)(uint16_t* dst,
+                                                  ptrdiff_t y_stride,
+                                                  const uint16_t* above,
+                                                  const uint16_t* left,
+                                                  int bd);
 
-void vpx_highbd_tm_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_tm_predictor_4x4)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_tm_predictor_4x4_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_tm_predictor_4x4)(uint16_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint16_t* above,
+                                                const uint16_t* left,
+                                                int bd);
 
-void vpx_highbd_tm_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_tm_predictor_8x8)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_tm_predictor_8x8_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_tm_predictor_8x8)(uint16_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint16_t* above,
+                                                const uint16_t* left,
+                                                int bd);
 
-void vpx_highbd_v_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_v_predictor_16x16)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
+void vpx_highbd_v_predictor_16x16_sse2(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
+RTCD_EXTERN void (*vpx_highbd_v_predictor_16x16)(uint16_t* dst,
+                                                 ptrdiff_t y_stride,
+                                                 const uint16_t* above,
+                                                 const uint16_t* left,
+                                                 int bd);
 
-void vpx_highbd_v_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_v_predictor_32x32)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
+void vpx_highbd_v_predictor_32x32_sse2(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
+RTCD_EXTERN void (*vpx_highbd_v_predictor_32x32)(uint16_t* dst,
+                                                 ptrdiff_t y_stride,
+                                                 const uint16_t* above,
+                                                 const uint16_t* left,
+                                                 int bd);
 
-void vpx_highbd_v_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_v_predictor_4x4)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
+void vpx_highbd_v_predictor_4x4_sse2(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_v_predictor_4x4)(uint16_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint16_t* above,
+                                               const uint16_t* left,
+                                               int bd);
 
-void vpx_highbd_v_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_v_predictor_8x8)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
+void vpx_highbd_v_predictor_8x8_sse2(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_v_predictor_8x8)(uint16_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint16_t* above,
+                                               const uint16_t* left,
+                                               int bd);
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_10_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_10_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_10_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+RTCD_EXTERN void (*vpx_idct16x16_10_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_1_add_sse2(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+RTCD_EXTERN void (*vpx_idct16x16_1_add)(const tran_low_t* input,
+                                        uint8_t* dest,
+                                        int stride);
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_256_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_256_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct16x16_256_add_sse2(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
+RTCD_EXTERN void (*vpx_idct16x16_256_add)(const tran_low_t* input,
+                                          uint8_t* dest,
+                                          int stride);
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_38_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_38_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_38_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+RTCD_EXTERN void (*vpx_idct16x16_38_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_1024_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+void vpx_idct32x32_1024_add_sse2(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+RTCD_EXTERN void (*vpx_idct32x32_1024_add)(const tran_low_t* input,
+                                           uint8_t* dest,
+                                           int stride);
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_135_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_135_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct32x32_1024_add_sse2(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+void vpx_idct32x32_135_add_ssse3(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+RTCD_EXTERN void (*vpx_idct32x32_135_add)(const tran_low_t* input,
+                                          uint8_t* dest,
+                                          int stride);
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_1_add_sse2(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+RTCD_EXTERN void (*vpx_idct32x32_1_add)(const tran_low_t* input,
+                                        uint8_t* dest,
+                                        int stride);
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_34_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_34_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+void vpx_idct32x32_34_add_ssse3(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
+RTCD_EXTERN void (*vpx_idct32x32_34_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct4x4_16_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_16_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+RTCD_EXTERN void (*vpx_idct4x4_16_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct4x4_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_1_add_sse2(const tran_low_t* input, uint8_t* dest, int stride);
+RTCD_EXTERN void (*vpx_idct4x4_1_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride);
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_12_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_12_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct8x8_12_add_ssse3(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+RTCD_EXTERN void (*vpx_idct8x8_12_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_1_add_sse2(const tran_low_t* input, uint8_t* dest, int stride);
+RTCD_EXTERN void (*vpx_idct8x8_1_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride);
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_64_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_64_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_64_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+RTCD_EXTERN void (*vpx_idct8x8_64_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
-int16_t vpx_int_pro_col_sse2(const uint8_t *ref, const int width);
-RTCD_EXTERN int16_t (*vpx_int_pro_col)(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
+int16_t vpx_int_pro_col_sse2(const uint8_t* ref, const int width);
+RTCD_EXTERN int16_t (*vpx_int_pro_col)(const uint8_t* ref, const int width);
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-void vpx_int_pro_row_sse2(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-RTCD_EXTERN void (*vpx_int_pro_row)(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
+void vpx_int_pro_row_sse2(int16_t* hbuf,
+                          const uint8_t* ref,
+                          const int ref_stride,
+                          const int height);
+RTCD_EXTERN void (*vpx_int_pro_row)(int16_t* hbuf,
+                                    const uint8_t* ref,
+                                    const int ref_stride,
+                                    const int height);
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_iwht4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_iwht4x4_16_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_iwht4x4_16_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+RTCD_EXTERN void (*vpx_iwht4x4_16_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_avx2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_16)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+void vpx_lpf_horizontal_16_sse2(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_horizontal_16_avx2(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_16)(uint8_t* s,
+                                          int pitch,
+                                          const uint8_t* blimit,
+                                          const uint8_t* limit,
+                                          const uint8_t* thresh);
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_avx2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_16_dual)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_sse2(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_avx2(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_16_dual)(uint8_t* s,
+                                               int pitch,
+                                               const uint8_t* blimit,
+                                               const uint8_t* limit,
+                                               const uint8_t* thresh);
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_4_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_4)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_4_sse2(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_4)(uint8_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh);
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_4_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_horizontal_4_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_4_dual_sse2(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_horizontal_4_dual)(uint8_t* s,
+                                              int pitch,
+                                              const uint8_t* blimit0,
+                                              const uint8_t* limit0,
+                                              const uint8_t* thresh0,
+                                              const uint8_t* blimit1,
+                                              const uint8_t* limit1,
+                                              const uint8_t* thresh1);
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_8_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_8)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_8_sse2(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_8)(uint8_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh);
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_8_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_horizontal_8_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_8_dual_sse2(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_horizontal_8_dual)(uint8_t* s,
+                                              int pitch,
+                                              const uint8_t* blimit0,
+                                              const uint8_t* limit0,
+                                              const uint8_t* thresh0,
+                                              const uint8_t* blimit1,
+                                              const uint8_t* limit1,
+                                              const uint8_t* thresh1);
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_16)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
+void vpx_lpf_vertical_16_sse2(uint8_t* s,
+                              int pitch,
+                              const uint8_t* blimit,
+                              const uint8_t* limit,
+                              const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_16)(uint8_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit,
+                                        const uint8_t* limit,
+                                        const uint8_t* thresh);
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_16_dual)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_vertical_16_dual_sse2(uint8_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_16_dual)(uint8_t* s,
+                                             int pitch,
+                                             const uint8_t* blimit,
+                                             const uint8_t* limit,
+                                             const uint8_t* thresh);
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_4_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_4)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_4_sse2(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_4)(uint8_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh);
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_4_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_vertical_4_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_4_dual_sse2(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_vertical_4_dual)(uint8_t* s,
+                                            int pitch,
+                                            const uint8_t* blimit0,
+                                            const uint8_t* limit0,
+                                            const uint8_t* thresh0,
+                                            const uint8_t* blimit1,
+                                            const uint8_t* limit1,
+                                            const uint8_t* thresh1);
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_8_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_8)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_8_sse2(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_8)(uint8_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh);
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_8_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_vertical_8_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_8_dual_sse2(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_vertical_8_dual)(uint8_t* s,
+                                            int pitch,
+                                            const uint8_t* blimit0,
+                                            const uint8_t* limit0,
+                                            const uint8_t* thresh0,
+                                            const uint8_t* blimit1,
+                                            const uint8_t* limit1,
+                                            const uint8_t* thresh1);
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_across_ip_sse2(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-RTCD_EXTERN void (*vpx_mbpost_proc_across_ip)(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
+void vpx_mbpost_proc_across_ip_sse2(unsigned char* dst,
+                                    int pitch,
+                                    int rows,
+                                    int cols,
+                                    int flimit);
+RTCD_EXTERN void (*vpx_mbpost_proc_across_ip)(unsigned char* dst,
+                                              int pitch,
+                                              int rows,
+                                              int cols,
+                                              int flimit);
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_down_sse2(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-RTCD_EXTERN void (*vpx_mbpost_proc_down)(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
+void vpx_mbpost_proc_down_sse2(unsigned char* dst,
+                               int pitch,
+                               int rows,
+                               int cols,
+                               int flimit);
+RTCD_EXTERN void (*vpx_mbpost_proc_down)(unsigned char* dst,
+                                         int pitch,
+                                         int rows,
+                                         int cols,
+                                         int flimit);
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-void vpx_minmax_8x8_sse2(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-RTCD_EXTERN void (*vpx_minmax_8x8)(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
+void vpx_minmax_8x8_sse2(const uint8_t* s,
+                         int p,
+                         const uint8_t* d,
+                         int dp,
+                         int* min,
+                         int* max);
+RTCD_EXTERN void (*vpx_minmax_8x8)(const uint8_t* s,
+                                   int p,
+                                   const uint8_t* d,
+                                   int dp,
+                                   int* min,
+                                   int* max);
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_avx2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
+unsigned int vpx_mse16x16_sse2(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
+unsigned int vpx_mse16x16_avx2(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse16x16)(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse16x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
+unsigned int vpx_mse16x8_sse2(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int recon_stride,
+                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse16x8)(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int recon_stride,
+                                        unsigned int* sse);
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse8x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse8x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
+unsigned int vpx_mse8x16_sse2(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int recon_stride,
+                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse8x16)(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int recon_stride,
+                                        unsigned int* sse);
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse8x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
+unsigned int vpx_mse8x8_sse2(const uint8_t* src_ptr,
+                             int source_stride,
+                             const uint8_t* ref_ptr,
+                             int recon_stride,
+                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse8x8)(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
-void vpx_plane_add_noise_sse2(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
-RTCD_EXTERN void (*vpx_plane_add_noise)(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
+void vpx_plane_add_noise_sse2(uint8_t* start,
+                              const int8_t* noise,
+                              int blackclamp,
+                              int whiteclamp,
+                              int width,
+                              int height,
+                              int pitch);
+RTCD_EXTERN void (*vpx_plane_add_noise)(uint8_t* start,
+                                        const int8_t* noise,
+                                        int blackclamp,
+                                        int whiteclamp,
+                                        int width,
+                                        int height,
+                                        int pitch);
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-void vpx_post_proc_down_and_across_mb_row_sse2(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-RTCD_EXTERN void (*vpx_post_proc_down_and_across_mb_row)(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+void vpx_post_proc_down_and_across_mb_row_sse2(unsigned char* src,
+                                               unsigned char* dst,
+                                               int src_pitch,
+                                               int dst_pitch,
+                                               int cols,
+                                               unsigned char* flimits,
+                                               int size);
+RTCD_EXTERN void (*vpx_post_proc_down_and_across_mb_row)(unsigned char* src,
+                                                         unsigned char* dst,
+                                                         int src_pitch,
+                                                         int dst_pitch,
+                                                         int cols,
+                                                         unsigned char* flimits,
+                                                         int size);
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_quantize_b)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
+void vpx_quantize_b_sse2(const tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* zbin_ptr,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         const int16_t* quant_shift_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+RTCD_EXTERN void (*vpx_quantize_b)(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vpx_quantize_b_32x32 vpx_quantize_b_32x32_c
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad16x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x16_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad16x16)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad16x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x16_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad16x16_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x3_ssse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x16x3_sse3(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+void vpx_sad16x16x3_ssse3(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x3)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x16x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x16x8_sse4_1(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride,
+                           uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x8)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad16x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad16x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad16x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad16x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad16x8_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad16x8)(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad16x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad16x8_avg_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad16x8_avg)(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            const uint8_t* second_pred);
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x3_ssse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad16x8x3_sse3(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        uint32_t* sad_array);
+void vpx_sad16x8x3_ssse3(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x3)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x8x4d_sse2(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x4d)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad16x8x8_sse4_1(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x8)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x16_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x16_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x16)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x16_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x16x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x16x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x32_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+void vpx_sad32x32x4d_avx2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x64_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x64_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x64)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x64_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x64x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x64x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad4x4)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x4_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad4x4)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad4x4_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x4_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad4x4_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad4x4x3_sse3(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x3)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x4x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad4x4x8_sse4_1(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x8)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad4x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x8_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad4x8)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad4x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x8_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad4x8_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x8x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x8x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad64x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad64x32_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad64x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad64x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad64x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad64x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad64x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad64x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x64_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad64x64_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad64x64)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad64x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad64x64_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad64x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x64x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+void vpx_sad64x64x4d_avx2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad64x64x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad8x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad8x16_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad8x16)(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad8x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad8x16_avg_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad8x16_avg)(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            const uint8_t* second_pred);
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x16x3_sse3(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x3)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad8x16x4d_sse2(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x4d)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x16x8_sse4_1(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x8)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad8x4)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x4_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad8x4)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad8x4_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x4_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad8x4_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x4x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x4x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x4x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x8_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad8x8)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad8x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x8_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad8x8_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad8x8x3_sse3(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x3)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x8x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad8x8x8_sse4_1(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x8)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-int vpx_satd_c(const tran_low_t *coeff, int length);
-int vpx_satd_sse2(const tran_low_t *coeff, int length);
-RTCD_EXTERN int (*vpx_satd)(const tran_low_t *coeff, int length);
+int vpx_satd_c(const tran_low_t* coeff, int length);
+int vpx_satd_sse2(const tran_low_t* coeff, int length);
+RTCD_EXTERN int (*vpx_satd)(const tran_low_t* coeff, int length);
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_scaled_2d_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_scaled_2d)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_scaled_2d_ssse3(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+RTCD_EXTERN void (*vpx_scaled_2d)(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_ssse3(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_avx2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_avx2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_ssse3(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x16)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_ssse3(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x8)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x16)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_avx2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x64)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x4)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x8)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_avx2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x64)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_ssse3(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x16)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x4)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x8)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-void vpx_subtract_block_sse2(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-RTCD_EXTERN void (*vpx_subtract_block)(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
+void vpx_subtract_block_sse2(int rows,
+                             int cols,
+                             int16_t* diff_ptr,
+                             ptrdiff_t diff_stride,
+                             const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             const uint8_t* pred_ptr,
+                             ptrdiff_t pred_stride);
+RTCD_EXTERN void (*vpx_subtract_block)(int rows,
+                                       int cols,
+                                       int16_t* diff_ptr,
+                                       ptrdiff_t diff_stride,
+                                       const uint8_t* src_ptr,
+                                       ptrdiff_t src_stride,
+                                       const uint8_t* pred_ptr,
+                                       ptrdiff_t pred_stride);
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
-uint64_t vpx_sum_squares_2d_i16_sse2(const int16_t *src, int stride, int size);
-RTCD_EXTERN uint64_t (*vpx_sum_squares_2d_i16)(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_sse2(const int16_t* src, int stride, int size);
+RTCD_EXTERN uint64_t (*vpx_sum_squares_2d_i16)(const int16_t* src,
+                                               int stride,
+                                               int size);
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_16x16_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_16x16)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_32x32_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_32x32)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_4x4_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_4x4)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_8x8_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_8x8)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_16x16_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_16x16)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_32x32_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_32x32)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_4x4_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_4x4)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_8x8_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_8x8)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x16_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance16x16_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x16)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance16x8_sse2(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x8)(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x16_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance32x16_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x16)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance32x32_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x64_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x64)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance4x4)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x4_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance4x4)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance4x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x8_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance4x8)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance64x32_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance64x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x64_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance64x64_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance64x64)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance8x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance8x16_sse2(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance8x16)(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance8x4)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x4_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance8x4)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance8x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x8_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance8x8)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
-int vpx_vector_var_sse2(const int16_t *ref, const int16_t *src, const int bwl);
-RTCD_EXTERN int (*vpx_vector_var)(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
+int vpx_vector_var_sse2(const int16_t* ref, const int16_t* src, const int bwl);
+RTCD_EXTERN int (*vpx_vector_var)(const int16_t* ref,
+                                  const int16_t* src,
+                                  const int bwl);
 
 void vpx_dsp_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vpx_avg_4x4 = vpx_avg_4x4_c;
-    if (flags & HAS_SSE2) vpx_avg_4x4 = vpx_avg_4x4_sse2;
-    vpx_avg_8x8 = vpx_avg_8x8_c;
-    if (flags & HAS_SSE2) vpx_avg_8x8 = vpx_avg_8x8_sse2;
-    vpx_comp_avg_pred = vpx_comp_avg_pred_c;
-    if (flags & HAS_SSE2) vpx_comp_avg_pred = vpx_comp_avg_pred_sse2;
-    vpx_convolve8 = vpx_convolve8_c;
-    if (flags & HAS_SSE2) vpx_convolve8 = vpx_convolve8_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8 = vpx_convolve8_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8 = vpx_convolve8_avx2;
-    vpx_convolve8_avg = vpx_convolve8_avg_c;
-    if (flags & HAS_SSE2) vpx_convolve8_avg = vpx_convolve8_avg_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg = vpx_convolve8_avg_ssse3;
-    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_c;
-    if (flags & HAS_SSE2) vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_ssse3;
-    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_c;
-    if (flags & HAS_SSE2) vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_ssse3;
-    vpx_convolve8_horiz = vpx_convolve8_horiz_c;
-    if (flags & HAS_SSE2) vpx_convolve8_horiz = vpx_convolve8_horiz_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_horiz = vpx_convolve8_horiz_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8_horiz = vpx_convolve8_horiz_avx2;
-    vpx_convolve8_vert = vpx_convolve8_vert_c;
-    if (flags & HAS_SSE2) vpx_convolve8_vert = vpx_convolve8_vert_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_vert = vpx_convolve8_vert_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8_vert = vpx_convolve8_vert_avx2;
-    vpx_convolve_avg = vpx_convolve_avg_c;
-    if (flags & HAS_SSE2) vpx_convolve_avg = vpx_convolve_avg_sse2;
-    vpx_convolve_copy = vpx_convolve_copy_c;
-    if (flags & HAS_SSE2) vpx_convolve_copy = vpx_convolve_copy_sse2;
-    vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_ssse3;
-    vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_ssse3;
-    vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_ssse3;
-    vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_ssse3;
-    vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_ssse3;
-    vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_ssse3;
-    vpx_d207_predictor_4x4 = vpx_d207_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_d207_predictor_4x4 = vpx_d207_predictor_4x4_sse2;
-    vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_ssse3;
-    vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_ssse3;
-    vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_ssse3;
-    vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_sse2;
-    vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_sse2;
-    vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_ssse3;
-    vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_ssse3;
-    vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_ssse3;
-    vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_ssse3;
-    vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_sse2;
-    vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_sse2;
-    vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_sse2;
-    vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_sse2;
-    vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_sse2;
-    vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_sse2;
-    vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_sse2;
-    vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_sse2;
-    vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_sse2;
-    vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_sse2;
-    vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_sse2;
-    vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_sse2;
-    vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_sse2;
-    vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_sse2;
-    vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_sse2;
-    vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_sse2;
-    vpx_fdct16x16 = vpx_fdct16x16_c;
-    if (flags & HAS_SSE2) vpx_fdct16x16 = vpx_fdct16x16_sse2;
-    vpx_fdct16x16_1 = vpx_fdct16x16_1_c;
-    if (flags & HAS_SSE2) vpx_fdct16x16_1 = vpx_fdct16x16_1_sse2;
-    vpx_fdct32x32 = vpx_fdct32x32_c;
-    if (flags & HAS_SSE2) vpx_fdct32x32 = vpx_fdct32x32_sse2;
-    vpx_fdct32x32_1 = vpx_fdct32x32_1_c;
-    if (flags & HAS_SSE2) vpx_fdct32x32_1 = vpx_fdct32x32_1_sse2;
-    vpx_fdct32x32_rd = vpx_fdct32x32_rd_c;
-    if (flags & HAS_SSE2) vpx_fdct32x32_rd = vpx_fdct32x32_rd_sse2;
-    vpx_fdct4x4 = vpx_fdct4x4_c;
-    if (flags & HAS_SSE2) vpx_fdct4x4 = vpx_fdct4x4_sse2;
-    vpx_fdct4x4_1 = vpx_fdct4x4_1_c;
-    if (flags & HAS_SSE2) vpx_fdct4x4_1 = vpx_fdct4x4_1_sse2;
-    vpx_fdct8x8 = vpx_fdct8x8_c;
-    if (flags & HAS_SSE2) vpx_fdct8x8 = vpx_fdct8x8_sse2;
-    vpx_fdct8x8_1 = vpx_fdct8x8_1_c;
-    if (flags & HAS_SSE2) vpx_fdct8x8_1 = vpx_fdct8x8_1_sse2;
-    vpx_get16x16var = vpx_get16x16var_c;
-    if (flags & HAS_SSE2) vpx_get16x16var = vpx_get16x16var_sse2;
-    if (flags & HAS_AVX2) vpx_get16x16var = vpx_get16x16var_avx2;
-    vpx_get8x8var = vpx_get8x8var_c;
-    if (flags & HAS_SSE2) vpx_get8x8var = vpx_get8x8var_sse2;
-    vpx_get_mb_ss = vpx_get_mb_ss_c;
-    if (flags & HAS_SSE2) vpx_get_mb_ss = vpx_get_mb_ss_sse2;
-    vpx_h_predictor_16x16 = vpx_h_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_h_predictor_16x16 = vpx_h_predictor_16x16_sse2;
-    vpx_h_predictor_32x32 = vpx_h_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_h_predictor_32x32 = vpx_h_predictor_32x32_sse2;
-    vpx_h_predictor_4x4 = vpx_h_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_h_predictor_4x4 = vpx_h_predictor_4x4_sse2;
-    vpx_h_predictor_8x8 = vpx_h_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_h_predictor_8x8 = vpx_h_predictor_8x8_sse2;
-    vpx_hadamard_16x16 = vpx_hadamard_16x16_c;
-    if (flags & HAS_SSE2) vpx_hadamard_16x16 = vpx_hadamard_16x16_sse2;
-    vpx_hadamard_8x8 = vpx_hadamard_8x8_c;
-    if (flags & HAS_SSE2) vpx_hadamard_8x8 = vpx_hadamard_8x8_sse2;
-    vpx_highbd_10_mse16x16 = vpx_highbd_10_mse16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_mse16x16 = vpx_highbd_10_mse16x16_sse2;
-    vpx_highbd_10_mse8x8 = vpx_highbd_10_mse8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_mse8x8 = vpx_highbd_10_mse8x8_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance16x16 = vpx_highbd_10_sub_pixel_avg_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance16x16 = vpx_highbd_10_sub_pixel_avg_variance16x16_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance16x32 = vpx_highbd_10_sub_pixel_avg_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance16x32 = vpx_highbd_10_sub_pixel_avg_variance16x32_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance16x8 = vpx_highbd_10_sub_pixel_avg_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance16x8 = vpx_highbd_10_sub_pixel_avg_variance16x8_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance32x16 = vpx_highbd_10_sub_pixel_avg_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance32x16 = vpx_highbd_10_sub_pixel_avg_variance32x16_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance32x32 = vpx_highbd_10_sub_pixel_avg_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance32x32 = vpx_highbd_10_sub_pixel_avg_variance32x32_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance32x64 = vpx_highbd_10_sub_pixel_avg_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance32x64 = vpx_highbd_10_sub_pixel_avg_variance32x64_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance64x32 = vpx_highbd_10_sub_pixel_avg_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance64x32 = vpx_highbd_10_sub_pixel_avg_variance64x32_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance64x64 = vpx_highbd_10_sub_pixel_avg_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance64x64 = vpx_highbd_10_sub_pixel_avg_variance64x64_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance8x16 = vpx_highbd_10_sub_pixel_avg_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance8x16 = vpx_highbd_10_sub_pixel_avg_variance8x16_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance8x4 = vpx_highbd_10_sub_pixel_avg_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance8x4 = vpx_highbd_10_sub_pixel_avg_variance8x4_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance8x8 = vpx_highbd_10_sub_pixel_avg_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance8x8 = vpx_highbd_10_sub_pixel_avg_variance8x8_sse2;
-    vpx_highbd_10_sub_pixel_variance16x16 = vpx_highbd_10_sub_pixel_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance16x16 = vpx_highbd_10_sub_pixel_variance16x16_sse2;
-    vpx_highbd_10_sub_pixel_variance16x32 = vpx_highbd_10_sub_pixel_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance16x32 = vpx_highbd_10_sub_pixel_variance16x32_sse2;
-    vpx_highbd_10_sub_pixel_variance16x8 = vpx_highbd_10_sub_pixel_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance16x8 = vpx_highbd_10_sub_pixel_variance16x8_sse2;
-    vpx_highbd_10_sub_pixel_variance32x16 = vpx_highbd_10_sub_pixel_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance32x16 = vpx_highbd_10_sub_pixel_variance32x16_sse2;
-    vpx_highbd_10_sub_pixel_variance32x32 = vpx_highbd_10_sub_pixel_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance32x32 = vpx_highbd_10_sub_pixel_variance32x32_sse2;
-    vpx_highbd_10_sub_pixel_variance32x64 = vpx_highbd_10_sub_pixel_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance32x64 = vpx_highbd_10_sub_pixel_variance32x64_sse2;
-    vpx_highbd_10_sub_pixel_variance64x32 = vpx_highbd_10_sub_pixel_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance64x32 = vpx_highbd_10_sub_pixel_variance64x32_sse2;
-    vpx_highbd_10_sub_pixel_variance64x64 = vpx_highbd_10_sub_pixel_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance64x64 = vpx_highbd_10_sub_pixel_variance64x64_sse2;
-    vpx_highbd_10_sub_pixel_variance8x16 = vpx_highbd_10_sub_pixel_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance8x16 = vpx_highbd_10_sub_pixel_variance8x16_sse2;
-    vpx_highbd_10_sub_pixel_variance8x4 = vpx_highbd_10_sub_pixel_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance8x4 = vpx_highbd_10_sub_pixel_variance8x4_sse2;
-    vpx_highbd_10_sub_pixel_variance8x8 = vpx_highbd_10_sub_pixel_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance8x8 = vpx_highbd_10_sub_pixel_variance8x8_sse2;
-    vpx_highbd_10_variance16x16 = vpx_highbd_10_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance16x16 = vpx_highbd_10_variance16x16_sse2;
-    vpx_highbd_10_variance16x32 = vpx_highbd_10_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance16x32 = vpx_highbd_10_variance16x32_sse2;
-    vpx_highbd_10_variance16x8 = vpx_highbd_10_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance16x8 = vpx_highbd_10_variance16x8_sse2;
-    vpx_highbd_10_variance32x16 = vpx_highbd_10_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance32x16 = vpx_highbd_10_variance32x16_sse2;
-    vpx_highbd_10_variance32x32 = vpx_highbd_10_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance32x32 = vpx_highbd_10_variance32x32_sse2;
-    vpx_highbd_10_variance32x64 = vpx_highbd_10_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance32x64 = vpx_highbd_10_variance32x64_sse2;
-    vpx_highbd_10_variance64x32 = vpx_highbd_10_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance64x32 = vpx_highbd_10_variance64x32_sse2;
-    vpx_highbd_10_variance64x64 = vpx_highbd_10_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance64x64 = vpx_highbd_10_variance64x64_sse2;
-    vpx_highbd_10_variance8x16 = vpx_highbd_10_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance8x16 = vpx_highbd_10_variance8x16_sse2;
-    vpx_highbd_10_variance8x8 = vpx_highbd_10_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance8x8 = vpx_highbd_10_variance8x8_sse2;
-    vpx_highbd_12_mse16x16 = vpx_highbd_12_mse16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_mse16x16 = vpx_highbd_12_mse16x16_sse2;
-    vpx_highbd_12_mse8x8 = vpx_highbd_12_mse8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_mse8x8 = vpx_highbd_12_mse8x8_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance16x16 = vpx_highbd_12_sub_pixel_avg_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance16x16 = vpx_highbd_12_sub_pixel_avg_variance16x16_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance16x32 = vpx_highbd_12_sub_pixel_avg_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance16x32 = vpx_highbd_12_sub_pixel_avg_variance16x32_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance16x8 = vpx_highbd_12_sub_pixel_avg_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance16x8 = vpx_highbd_12_sub_pixel_avg_variance16x8_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance32x16 = vpx_highbd_12_sub_pixel_avg_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance32x16 = vpx_highbd_12_sub_pixel_avg_variance32x16_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance32x32 = vpx_highbd_12_sub_pixel_avg_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance32x32 = vpx_highbd_12_sub_pixel_avg_variance32x32_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance32x64 = vpx_highbd_12_sub_pixel_avg_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance32x64 = vpx_highbd_12_sub_pixel_avg_variance32x64_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance64x32 = vpx_highbd_12_sub_pixel_avg_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance64x32 = vpx_highbd_12_sub_pixel_avg_variance64x32_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance64x64 = vpx_highbd_12_sub_pixel_avg_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance64x64 = vpx_highbd_12_sub_pixel_avg_variance64x64_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance8x16 = vpx_highbd_12_sub_pixel_avg_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance8x16 = vpx_highbd_12_sub_pixel_avg_variance8x16_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance8x4 = vpx_highbd_12_sub_pixel_avg_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance8x4 = vpx_highbd_12_sub_pixel_avg_variance8x4_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance8x8 = vpx_highbd_12_sub_pixel_avg_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance8x8 = vpx_highbd_12_sub_pixel_avg_variance8x8_sse2;
-    vpx_highbd_12_sub_pixel_variance16x16 = vpx_highbd_12_sub_pixel_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance16x16 = vpx_highbd_12_sub_pixel_variance16x16_sse2;
-    vpx_highbd_12_sub_pixel_variance16x32 = vpx_highbd_12_sub_pixel_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance16x32 = vpx_highbd_12_sub_pixel_variance16x32_sse2;
-    vpx_highbd_12_sub_pixel_variance16x8 = vpx_highbd_12_sub_pixel_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance16x8 = vpx_highbd_12_sub_pixel_variance16x8_sse2;
-    vpx_highbd_12_sub_pixel_variance32x16 = vpx_highbd_12_sub_pixel_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance32x16 = vpx_highbd_12_sub_pixel_variance32x16_sse2;
-    vpx_highbd_12_sub_pixel_variance32x32 = vpx_highbd_12_sub_pixel_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance32x32 = vpx_highbd_12_sub_pixel_variance32x32_sse2;
-    vpx_highbd_12_sub_pixel_variance32x64 = vpx_highbd_12_sub_pixel_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance32x64 = vpx_highbd_12_sub_pixel_variance32x64_sse2;
-    vpx_highbd_12_sub_pixel_variance64x32 = vpx_highbd_12_sub_pixel_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance64x32 = vpx_highbd_12_sub_pixel_variance64x32_sse2;
-    vpx_highbd_12_sub_pixel_variance64x64 = vpx_highbd_12_sub_pixel_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance64x64 = vpx_highbd_12_sub_pixel_variance64x64_sse2;
-    vpx_highbd_12_sub_pixel_variance8x16 = vpx_highbd_12_sub_pixel_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance8x16 = vpx_highbd_12_sub_pixel_variance8x16_sse2;
-    vpx_highbd_12_sub_pixel_variance8x4 = vpx_highbd_12_sub_pixel_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance8x4 = vpx_highbd_12_sub_pixel_variance8x4_sse2;
-    vpx_highbd_12_sub_pixel_variance8x8 = vpx_highbd_12_sub_pixel_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance8x8 = vpx_highbd_12_sub_pixel_variance8x8_sse2;
-    vpx_highbd_12_variance16x16 = vpx_highbd_12_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance16x16 = vpx_highbd_12_variance16x16_sse2;
-    vpx_highbd_12_variance16x32 = vpx_highbd_12_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance16x32 = vpx_highbd_12_variance16x32_sse2;
-    vpx_highbd_12_variance16x8 = vpx_highbd_12_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance16x8 = vpx_highbd_12_variance16x8_sse2;
-    vpx_highbd_12_variance32x16 = vpx_highbd_12_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance32x16 = vpx_highbd_12_variance32x16_sse2;
-    vpx_highbd_12_variance32x32 = vpx_highbd_12_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance32x32 = vpx_highbd_12_variance32x32_sse2;
-    vpx_highbd_12_variance32x64 = vpx_highbd_12_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance32x64 = vpx_highbd_12_variance32x64_sse2;
-    vpx_highbd_12_variance64x32 = vpx_highbd_12_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance64x32 = vpx_highbd_12_variance64x32_sse2;
-    vpx_highbd_12_variance64x64 = vpx_highbd_12_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance64x64 = vpx_highbd_12_variance64x64_sse2;
-    vpx_highbd_12_variance8x16 = vpx_highbd_12_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance8x16 = vpx_highbd_12_variance8x16_sse2;
-    vpx_highbd_12_variance8x8 = vpx_highbd_12_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance8x8 = vpx_highbd_12_variance8x8_sse2;
-    vpx_highbd_8_mse16x16 = vpx_highbd_8_mse16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_mse16x16 = vpx_highbd_8_mse16x16_sse2;
-    vpx_highbd_8_mse8x8 = vpx_highbd_8_mse8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_mse8x8 = vpx_highbd_8_mse8x8_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance16x16 = vpx_highbd_8_sub_pixel_avg_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance16x16 = vpx_highbd_8_sub_pixel_avg_variance16x16_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance16x32 = vpx_highbd_8_sub_pixel_avg_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance16x32 = vpx_highbd_8_sub_pixel_avg_variance16x32_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance16x8 = vpx_highbd_8_sub_pixel_avg_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance16x8 = vpx_highbd_8_sub_pixel_avg_variance16x8_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance32x16 = vpx_highbd_8_sub_pixel_avg_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance32x16 = vpx_highbd_8_sub_pixel_avg_variance32x16_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance32x32 = vpx_highbd_8_sub_pixel_avg_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance32x32 = vpx_highbd_8_sub_pixel_avg_variance32x32_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance32x64 = vpx_highbd_8_sub_pixel_avg_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance32x64 = vpx_highbd_8_sub_pixel_avg_variance32x64_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance64x32 = vpx_highbd_8_sub_pixel_avg_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance64x32 = vpx_highbd_8_sub_pixel_avg_variance64x32_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance64x64 = vpx_highbd_8_sub_pixel_avg_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance64x64 = vpx_highbd_8_sub_pixel_avg_variance64x64_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance8x16 = vpx_highbd_8_sub_pixel_avg_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance8x16 = vpx_highbd_8_sub_pixel_avg_variance8x16_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance8x4 = vpx_highbd_8_sub_pixel_avg_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance8x4 = vpx_highbd_8_sub_pixel_avg_variance8x4_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance8x8 = vpx_highbd_8_sub_pixel_avg_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance8x8 = vpx_highbd_8_sub_pixel_avg_variance8x8_sse2;
-    vpx_highbd_8_sub_pixel_variance16x16 = vpx_highbd_8_sub_pixel_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance16x16 = vpx_highbd_8_sub_pixel_variance16x16_sse2;
-    vpx_highbd_8_sub_pixel_variance16x32 = vpx_highbd_8_sub_pixel_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance16x32 = vpx_highbd_8_sub_pixel_variance16x32_sse2;
-    vpx_highbd_8_sub_pixel_variance16x8 = vpx_highbd_8_sub_pixel_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance16x8 = vpx_highbd_8_sub_pixel_variance16x8_sse2;
-    vpx_highbd_8_sub_pixel_variance32x16 = vpx_highbd_8_sub_pixel_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance32x16 = vpx_highbd_8_sub_pixel_variance32x16_sse2;
-    vpx_highbd_8_sub_pixel_variance32x32 = vpx_highbd_8_sub_pixel_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance32x32 = vpx_highbd_8_sub_pixel_variance32x32_sse2;
-    vpx_highbd_8_sub_pixel_variance32x64 = vpx_highbd_8_sub_pixel_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance32x64 = vpx_highbd_8_sub_pixel_variance32x64_sse2;
-    vpx_highbd_8_sub_pixel_variance64x32 = vpx_highbd_8_sub_pixel_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance64x32 = vpx_highbd_8_sub_pixel_variance64x32_sse2;
-    vpx_highbd_8_sub_pixel_variance64x64 = vpx_highbd_8_sub_pixel_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance64x64 = vpx_highbd_8_sub_pixel_variance64x64_sse2;
-    vpx_highbd_8_sub_pixel_variance8x16 = vpx_highbd_8_sub_pixel_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance8x16 = vpx_highbd_8_sub_pixel_variance8x16_sse2;
-    vpx_highbd_8_sub_pixel_variance8x4 = vpx_highbd_8_sub_pixel_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance8x4 = vpx_highbd_8_sub_pixel_variance8x4_sse2;
-    vpx_highbd_8_sub_pixel_variance8x8 = vpx_highbd_8_sub_pixel_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance8x8 = vpx_highbd_8_sub_pixel_variance8x8_sse2;
-    vpx_highbd_8_variance16x16 = vpx_highbd_8_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance16x16 = vpx_highbd_8_variance16x16_sse2;
-    vpx_highbd_8_variance16x32 = vpx_highbd_8_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance16x32 = vpx_highbd_8_variance16x32_sse2;
-    vpx_highbd_8_variance16x8 = vpx_highbd_8_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance16x8 = vpx_highbd_8_variance16x8_sse2;
-    vpx_highbd_8_variance32x16 = vpx_highbd_8_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance32x16 = vpx_highbd_8_variance32x16_sse2;
-    vpx_highbd_8_variance32x32 = vpx_highbd_8_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance32x32 = vpx_highbd_8_variance32x32_sse2;
-    vpx_highbd_8_variance32x64 = vpx_highbd_8_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance32x64 = vpx_highbd_8_variance32x64_sse2;
-    vpx_highbd_8_variance64x32 = vpx_highbd_8_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance64x32 = vpx_highbd_8_variance64x32_sse2;
-    vpx_highbd_8_variance64x64 = vpx_highbd_8_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance64x64 = vpx_highbd_8_variance64x64_sse2;
-    vpx_highbd_8_variance8x16 = vpx_highbd_8_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance8x16 = vpx_highbd_8_variance8x16_sse2;
-    vpx_highbd_8_variance8x8 = vpx_highbd_8_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance8x8 = vpx_highbd_8_variance8x8_sse2;
-    vpx_highbd_convolve8 = vpx_highbd_convolve8_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8 = vpx_highbd_convolve8_avx2;
-    vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_avx2;
-    vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_avx2;
-    vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_avx2;
-    vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_avx2;
-    vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_avx2;
-    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_avx2;
-    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_c;
-    if (flags & HAS_SSE2) vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_avx2;
-    vpx_highbd_dc_predictor_16x16 = vpx_highbd_dc_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_dc_predictor_16x16 = vpx_highbd_dc_predictor_16x16_sse2;
-    vpx_highbd_dc_predictor_32x32 = vpx_highbd_dc_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_dc_predictor_32x32 = vpx_highbd_dc_predictor_32x32_sse2;
-    vpx_highbd_dc_predictor_4x4 = vpx_highbd_dc_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_dc_predictor_4x4 = vpx_highbd_dc_predictor_4x4_sse2;
-    vpx_highbd_dc_predictor_8x8 = vpx_highbd_dc_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_dc_predictor_8x8 = vpx_highbd_dc_predictor_8x8_sse2;
-    vpx_highbd_fdct16x16 = vpx_highbd_fdct16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct16x16 = vpx_highbd_fdct16x16_sse2;
-    vpx_highbd_fdct32x32 = vpx_highbd_fdct32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct32x32 = vpx_highbd_fdct32x32_sse2;
-    vpx_highbd_fdct32x32_rd = vpx_highbd_fdct32x32_rd_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct32x32_rd = vpx_highbd_fdct32x32_rd_sse2;
-    vpx_highbd_fdct4x4 = vpx_highbd_fdct4x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct4x4 = vpx_highbd_fdct4x4_sse2;
-    vpx_highbd_fdct8x8 = vpx_highbd_fdct8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct8x8 = vpx_highbd_fdct8x8_sse2;
-    vpx_highbd_idct16x16_10_add = vpx_highbd_idct16x16_10_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct16x16_10_add = vpx_highbd_idct16x16_10_add_sse2;
-    vpx_highbd_idct16x16_1_add = vpx_highbd_idct16x16_1_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct16x16_1_add = vpx_highbd_idct16x16_1_add_sse2;
-    vpx_highbd_idct16x16_256_add = vpx_highbd_idct16x16_256_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct16x16_256_add = vpx_highbd_idct16x16_256_add_sse2;
-    vpx_highbd_idct16x16_38_add = vpx_highbd_idct16x16_38_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct16x16_38_add = vpx_highbd_idct16x16_256_add_sse2;
-    vpx_highbd_idct32x32_1_add = vpx_highbd_idct32x32_1_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct32x32_1_add = vpx_highbd_idct32x32_1_add_sse2;
-    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse4_1;
-    vpx_highbd_idct4x4_1_add = vpx_highbd_idct4x4_1_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct4x4_1_add = vpx_highbd_idct4x4_1_add_sse2;
-    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse4_1;
-    vpx_highbd_idct8x8_1_add = vpx_highbd_idct8x8_1_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct8x8_1_add = vpx_highbd_idct8x8_1_add_sse2;
-    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse4_1;
-    vpx_highbd_lpf_horizontal_16 = vpx_highbd_lpf_horizontal_16_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_16 = vpx_highbd_lpf_horizontal_16_sse2;
-    vpx_highbd_lpf_horizontal_16_dual = vpx_highbd_lpf_horizontal_16_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_16_dual = vpx_highbd_lpf_horizontal_16_dual_sse2;
-    vpx_highbd_lpf_horizontal_4 = vpx_highbd_lpf_horizontal_4_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_4 = vpx_highbd_lpf_horizontal_4_sse2;
-    vpx_highbd_lpf_horizontal_4_dual = vpx_highbd_lpf_horizontal_4_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_4_dual = vpx_highbd_lpf_horizontal_4_dual_sse2;
-    vpx_highbd_lpf_horizontal_8 = vpx_highbd_lpf_horizontal_8_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_8 = vpx_highbd_lpf_horizontal_8_sse2;
-    vpx_highbd_lpf_horizontal_8_dual = vpx_highbd_lpf_horizontal_8_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_8_dual = vpx_highbd_lpf_horizontal_8_dual_sse2;
-    vpx_highbd_lpf_vertical_16 = vpx_highbd_lpf_vertical_16_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_16 = vpx_highbd_lpf_vertical_16_sse2;
-    vpx_highbd_lpf_vertical_16_dual = vpx_highbd_lpf_vertical_16_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_16_dual = vpx_highbd_lpf_vertical_16_dual_sse2;
-    vpx_highbd_lpf_vertical_4 = vpx_highbd_lpf_vertical_4_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_4 = vpx_highbd_lpf_vertical_4_sse2;
-    vpx_highbd_lpf_vertical_4_dual = vpx_highbd_lpf_vertical_4_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_4_dual = vpx_highbd_lpf_vertical_4_dual_sse2;
-    vpx_highbd_lpf_vertical_8 = vpx_highbd_lpf_vertical_8_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_8 = vpx_highbd_lpf_vertical_8_sse2;
-    vpx_highbd_lpf_vertical_8_dual = vpx_highbd_lpf_vertical_8_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_8_dual = vpx_highbd_lpf_vertical_8_dual_sse2;
-    vpx_highbd_quantize_b = vpx_highbd_quantize_b_c;
-    if (flags & HAS_SSE2) vpx_highbd_quantize_b = vpx_highbd_quantize_b_sse2;
-    vpx_highbd_quantize_b_32x32 = vpx_highbd_quantize_b_32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_quantize_b_32x32 = vpx_highbd_quantize_b_32x32_sse2;
-    vpx_highbd_sad16x16 = vpx_highbd_sad16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x16 = vpx_highbd_sad16x16_sse2;
-    vpx_highbd_sad16x16_avg = vpx_highbd_sad16x16_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x16_avg = vpx_highbd_sad16x16_avg_sse2;
-    vpx_highbd_sad16x16x4d = vpx_highbd_sad16x16x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x16x4d = vpx_highbd_sad16x16x4d_sse2;
-    vpx_highbd_sad16x32 = vpx_highbd_sad16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x32 = vpx_highbd_sad16x32_sse2;
-    vpx_highbd_sad16x32_avg = vpx_highbd_sad16x32_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x32_avg = vpx_highbd_sad16x32_avg_sse2;
-    vpx_highbd_sad16x32x4d = vpx_highbd_sad16x32x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x32x4d = vpx_highbd_sad16x32x4d_sse2;
-    vpx_highbd_sad16x8 = vpx_highbd_sad16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x8 = vpx_highbd_sad16x8_sse2;
-    vpx_highbd_sad16x8_avg = vpx_highbd_sad16x8_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x8_avg = vpx_highbd_sad16x8_avg_sse2;
-    vpx_highbd_sad16x8x4d = vpx_highbd_sad16x8x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x8x4d = vpx_highbd_sad16x8x4d_sse2;
-    vpx_highbd_sad32x16 = vpx_highbd_sad32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x16 = vpx_highbd_sad32x16_sse2;
-    vpx_highbd_sad32x16_avg = vpx_highbd_sad32x16_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x16_avg = vpx_highbd_sad32x16_avg_sse2;
-    vpx_highbd_sad32x16x4d = vpx_highbd_sad32x16x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x16x4d = vpx_highbd_sad32x16x4d_sse2;
-    vpx_highbd_sad32x32 = vpx_highbd_sad32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x32 = vpx_highbd_sad32x32_sse2;
-    vpx_highbd_sad32x32_avg = vpx_highbd_sad32x32_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x32_avg = vpx_highbd_sad32x32_avg_sse2;
-    vpx_highbd_sad32x32x4d = vpx_highbd_sad32x32x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x32x4d = vpx_highbd_sad32x32x4d_sse2;
-    vpx_highbd_sad32x64 = vpx_highbd_sad32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x64 = vpx_highbd_sad32x64_sse2;
-    vpx_highbd_sad32x64_avg = vpx_highbd_sad32x64_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x64_avg = vpx_highbd_sad32x64_avg_sse2;
-    vpx_highbd_sad32x64x4d = vpx_highbd_sad32x64x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x64x4d = vpx_highbd_sad32x64x4d_sse2;
-    vpx_highbd_sad4x4x4d = vpx_highbd_sad4x4x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad4x4x4d = vpx_highbd_sad4x4x4d_sse2;
-    vpx_highbd_sad4x8x4d = vpx_highbd_sad4x8x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad4x8x4d = vpx_highbd_sad4x8x4d_sse2;
-    vpx_highbd_sad64x32 = vpx_highbd_sad64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x32 = vpx_highbd_sad64x32_sse2;
-    vpx_highbd_sad64x32_avg = vpx_highbd_sad64x32_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x32_avg = vpx_highbd_sad64x32_avg_sse2;
-    vpx_highbd_sad64x32x4d = vpx_highbd_sad64x32x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x32x4d = vpx_highbd_sad64x32x4d_sse2;
-    vpx_highbd_sad64x64 = vpx_highbd_sad64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x64 = vpx_highbd_sad64x64_sse2;
-    vpx_highbd_sad64x64_avg = vpx_highbd_sad64x64_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x64_avg = vpx_highbd_sad64x64_avg_sse2;
-    vpx_highbd_sad64x64x4d = vpx_highbd_sad64x64x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x64x4d = vpx_highbd_sad64x64x4d_sse2;
-    vpx_highbd_sad8x16 = vpx_highbd_sad8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x16 = vpx_highbd_sad8x16_sse2;
-    vpx_highbd_sad8x16_avg = vpx_highbd_sad8x16_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x16_avg = vpx_highbd_sad8x16_avg_sse2;
-    vpx_highbd_sad8x16x4d = vpx_highbd_sad8x16x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x16x4d = vpx_highbd_sad8x16x4d_sse2;
-    vpx_highbd_sad8x4 = vpx_highbd_sad8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x4 = vpx_highbd_sad8x4_sse2;
-    vpx_highbd_sad8x4_avg = vpx_highbd_sad8x4_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x4_avg = vpx_highbd_sad8x4_avg_sse2;
-    vpx_highbd_sad8x4x4d = vpx_highbd_sad8x4x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x4x4d = vpx_highbd_sad8x4x4d_sse2;
-    vpx_highbd_sad8x8 = vpx_highbd_sad8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x8 = vpx_highbd_sad8x8_sse2;
-    vpx_highbd_sad8x8_avg = vpx_highbd_sad8x8_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x8_avg = vpx_highbd_sad8x8_avg_sse2;
-    vpx_highbd_sad8x8x4d = vpx_highbd_sad8x8x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x8x4d = vpx_highbd_sad8x8x4d_sse2;
-    vpx_highbd_tm_predictor_16x16 = vpx_highbd_tm_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_tm_predictor_16x16 = vpx_highbd_tm_predictor_16x16_sse2;
-    vpx_highbd_tm_predictor_32x32 = vpx_highbd_tm_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_tm_predictor_32x32 = vpx_highbd_tm_predictor_32x32_sse2;
-    vpx_highbd_tm_predictor_4x4 = vpx_highbd_tm_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_tm_predictor_4x4 = vpx_highbd_tm_predictor_4x4_sse2;
-    vpx_highbd_tm_predictor_8x8 = vpx_highbd_tm_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_tm_predictor_8x8 = vpx_highbd_tm_predictor_8x8_sse2;
-    vpx_highbd_v_predictor_16x16 = vpx_highbd_v_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_v_predictor_16x16 = vpx_highbd_v_predictor_16x16_sse2;
-    vpx_highbd_v_predictor_32x32 = vpx_highbd_v_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_v_predictor_32x32 = vpx_highbd_v_predictor_32x32_sse2;
-    vpx_highbd_v_predictor_4x4 = vpx_highbd_v_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_v_predictor_4x4 = vpx_highbd_v_predictor_4x4_sse2;
-    vpx_highbd_v_predictor_8x8 = vpx_highbd_v_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_v_predictor_8x8 = vpx_highbd_v_predictor_8x8_sse2;
-    vpx_idct16x16_10_add = vpx_idct16x16_10_add_c;
-    if (flags & HAS_SSE2) vpx_idct16x16_10_add = vpx_idct16x16_10_add_sse2;
-    vpx_idct16x16_1_add = vpx_idct16x16_1_add_c;
-    if (flags & HAS_SSE2) vpx_idct16x16_1_add = vpx_idct16x16_1_add_sse2;
-    vpx_idct16x16_256_add = vpx_idct16x16_256_add_c;
-    if (flags & HAS_SSE2) vpx_idct16x16_256_add = vpx_idct16x16_256_add_sse2;
-    vpx_idct16x16_38_add = vpx_idct16x16_38_add_c;
-    if (flags & HAS_SSE2) vpx_idct16x16_38_add = vpx_idct16x16_38_add_sse2;
-    vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_c;
-    if (flags & HAS_SSE2) vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_sse2;
-    vpx_idct32x32_135_add = vpx_idct32x32_135_add_c;
-    if (flags & HAS_SSE2) vpx_idct32x32_135_add = vpx_idct32x32_1024_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct32x32_135_add = vpx_idct32x32_135_add_ssse3;
-    vpx_idct32x32_1_add = vpx_idct32x32_1_add_c;
-    if (flags & HAS_SSE2) vpx_idct32x32_1_add = vpx_idct32x32_1_add_sse2;
-    vpx_idct32x32_34_add = vpx_idct32x32_34_add_c;
-    if (flags & HAS_SSE2) vpx_idct32x32_34_add = vpx_idct32x32_34_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct32x32_34_add = vpx_idct32x32_34_add_ssse3;
-    vpx_idct4x4_16_add = vpx_idct4x4_16_add_c;
-    if (flags & HAS_SSE2) vpx_idct4x4_16_add = vpx_idct4x4_16_add_sse2;
-    vpx_idct4x4_1_add = vpx_idct4x4_1_add_c;
-    if (flags & HAS_SSE2) vpx_idct4x4_1_add = vpx_idct4x4_1_add_sse2;
-    vpx_idct8x8_12_add = vpx_idct8x8_12_add_c;
-    if (flags & HAS_SSE2) vpx_idct8x8_12_add = vpx_idct8x8_12_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct8x8_12_add = vpx_idct8x8_12_add_ssse3;
-    vpx_idct8x8_1_add = vpx_idct8x8_1_add_c;
-    if (flags & HAS_SSE2) vpx_idct8x8_1_add = vpx_idct8x8_1_add_sse2;
-    vpx_idct8x8_64_add = vpx_idct8x8_64_add_c;
-    if (flags & HAS_SSE2) vpx_idct8x8_64_add = vpx_idct8x8_64_add_sse2;
-    vpx_int_pro_col = vpx_int_pro_col_c;
-    if (flags & HAS_SSE2) vpx_int_pro_col = vpx_int_pro_col_sse2;
-    vpx_int_pro_row = vpx_int_pro_row_c;
-    if (flags & HAS_SSE2) vpx_int_pro_row = vpx_int_pro_row_sse2;
-    vpx_iwht4x4_16_add = vpx_iwht4x4_16_add_c;
-    if (flags & HAS_SSE2) vpx_iwht4x4_16_add = vpx_iwht4x4_16_add_sse2;
-    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_sse2;
-    if (flags & HAS_AVX2) vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_avx2;
-    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_sse2;
-    if (flags & HAS_AVX2) vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_avx2;
-    vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_sse2;
-    vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_sse2;
-    vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_sse2;
-    vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_sse2;
-    vpx_lpf_vertical_16 = vpx_lpf_vertical_16_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_16 = vpx_lpf_vertical_16_sse2;
-    vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_sse2;
-    vpx_lpf_vertical_4 = vpx_lpf_vertical_4_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_4 = vpx_lpf_vertical_4_sse2;
-    vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_sse2;
-    vpx_lpf_vertical_8 = vpx_lpf_vertical_8_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_8 = vpx_lpf_vertical_8_sse2;
-    vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_sse2;
-    vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_c;
-    if (flags & HAS_SSE2) vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_sse2;
-    vpx_mbpost_proc_down = vpx_mbpost_proc_down_c;
-    if (flags & HAS_SSE2) vpx_mbpost_proc_down = vpx_mbpost_proc_down_sse2;
-    vpx_minmax_8x8 = vpx_minmax_8x8_c;
-    if (flags & HAS_SSE2) vpx_minmax_8x8 = vpx_minmax_8x8_sse2;
-    vpx_mse16x16 = vpx_mse16x16_c;
-    if (flags & HAS_SSE2) vpx_mse16x16 = vpx_mse16x16_sse2;
-    if (flags & HAS_AVX2) vpx_mse16x16 = vpx_mse16x16_avx2;
-    vpx_mse16x8 = vpx_mse16x8_c;
-    if (flags & HAS_SSE2) vpx_mse16x8 = vpx_mse16x8_sse2;
-    vpx_mse8x16 = vpx_mse8x16_c;
-    if (flags & HAS_SSE2) vpx_mse8x16 = vpx_mse8x16_sse2;
-    vpx_mse8x8 = vpx_mse8x8_c;
-    if (flags & HAS_SSE2) vpx_mse8x8 = vpx_mse8x8_sse2;
-    vpx_plane_add_noise = vpx_plane_add_noise_c;
-    if (flags & HAS_SSE2) vpx_plane_add_noise = vpx_plane_add_noise_sse2;
-    vpx_post_proc_down_and_across_mb_row = vpx_post_proc_down_and_across_mb_row_c;
-    if (flags & HAS_SSE2) vpx_post_proc_down_and_across_mb_row = vpx_post_proc_down_and_across_mb_row_sse2;
-    vpx_quantize_b = vpx_quantize_b_c;
-    if (flags & HAS_SSE2) vpx_quantize_b = vpx_quantize_b_sse2;
-    vpx_sad16x16 = vpx_sad16x16_c;
-    if (flags & HAS_SSE2) vpx_sad16x16 = vpx_sad16x16_sse2;
-    vpx_sad16x16_avg = vpx_sad16x16_avg_c;
-    if (flags & HAS_SSE2) vpx_sad16x16_avg = vpx_sad16x16_avg_sse2;
-    vpx_sad16x16x3 = vpx_sad16x16x3_c;
-    if (flags & HAS_SSE3) vpx_sad16x16x3 = vpx_sad16x16x3_sse3;
-    if (flags & HAS_SSSE3) vpx_sad16x16x3 = vpx_sad16x16x3_ssse3;
-    vpx_sad16x16x4d = vpx_sad16x16x4d_c;
-    if (flags & HAS_SSE2) vpx_sad16x16x4d = vpx_sad16x16x4d_sse2;
-    vpx_sad16x16x8 = vpx_sad16x16x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad16x16x8 = vpx_sad16x16x8_sse4_1;
-    vpx_sad16x32 = vpx_sad16x32_c;
-    if (flags & HAS_SSE2) vpx_sad16x32 = vpx_sad16x32_sse2;
-    vpx_sad16x32_avg = vpx_sad16x32_avg_c;
-    if (flags & HAS_SSE2) vpx_sad16x32_avg = vpx_sad16x32_avg_sse2;
-    vpx_sad16x32x4d = vpx_sad16x32x4d_c;
-    if (flags & HAS_SSE2) vpx_sad16x32x4d = vpx_sad16x32x4d_sse2;
-    vpx_sad16x8 = vpx_sad16x8_c;
-    if (flags & HAS_SSE2) vpx_sad16x8 = vpx_sad16x8_sse2;
-    vpx_sad16x8_avg = vpx_sad16x8_avg_c;
-    if (flags & HAS_SSE2) vpx_sad16x8_avg = vpx_sad16x8_avg_sse2;
-    vpx_sad16x8x3 = vpx_sad16x8x3_c;
-    if (flags & HAS_SSE3) vpx_sad16x8x3 = vpx_sad16x8x3_sse3;
-    if (flags & HAS_SSSE3) vpx_sad16x8x3 = vpx_sad16x8x3_ssse3;
-    vpx_sad16x8x4d = vpx_sad16x8x4d_c;
-    if (flags & HAS_SSE2) vpx_sad16x8x4d = vpx_sad16x8x4d_sse2;
-    vpx_sad16x8x8 = vpx_sad16x8x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad16x8x8 = vpx_sad16x8x8_sse4_1;
-    vpx_sad32x16 = vpx_sad32x16_c;
-    if (flags & HAS_SSE2) vpx_sad32x16 = vpx_sad32x16_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x16 = vpx_sad32x16_avx2;
-    vpx_sad32x16_avg = vpx_sad32x16_avg_c;
-    if (flags & HAS_SSE2) vpx_sad32x16_avg = vpx_sad32x16_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x16_avg = vpx_sad32x16_avg_avx2;
-    vpx_sad32x16x4d = vpx_sad32x16x4d_c;
-    if (flags & HAS_SSE2) vpx_sad32x16x4d = vpx_sad32x16x4d_sse2;
-    vpx_sad32x32 = vpx_sad32x32_c;
-    if (flags & HAS_SSE2) vpx_sad32x32 = vpx_sad32x32_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32 = vpx_sad32x32_avx2;
-    vpx_sad32x32_avg = vpx_sad32x32_avg_c;
-    if (flags & HAS_SSE2) vpx_sad32x32_avg = vpx_sad32x32_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32_avg = vpx_sad32x32_avg_avx2;
-    vpx_sad32x32x4d = vpx_sad32x32x4d_c;
-    if (flags & HAS_SSE2) vpx_sad32x32x4d = vpx_sad32x32x4d_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32x4d = vpx_sad32x32x4d_avx2;
-    vpx_sad32x64 = vpx_sad32x64_c;
-    if (flags & HAS_SSE2) vpx_sad32x64 = vpx_sad32x64_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x64 = vpx_sad32x64_avx2;
-    vpx_sad32x64_avg = vpx_sad32x64_avg_c;
-    if (flags & HAS_SSE2) vpx_sad32x64_avg = vpx_sad32x64_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x64_avg = vpx_sad32x64_avg_avx2;
-    vpx_sad32x64x4d = vpx_sad32x64x4d_c;
-    if (flags & HAS_SSE2) vpx_sad32x64x4d = vpx_sad32x64x4d_sse2;
-    vpx_sad4x4 = vpx_sad4x4_c;
-    if (flags & HAS_SSE2) vpx_sad4x4 = vpx_sad4x4_sse2;
-    vpx_sad4x4_avg = vpx_sad4x4_avg_c;
-    if (flags & HAS_SSE2) vpx_sad4x4_avg = vpx_sad4x4_avg_sse2;
-    vpx_sad4x4x3 = vpx_sad4x4x3_c;
-    if (flags & HAS_SSE3) vpx_sad4x4x3 = vpx_sad4x4x3_sse3;
-    vpx_sad4x4x4d = vpx_sad4x4x4d_c;
-    if (flags & HAS_SSE2) vpx_sad4x4x4d = vpx_sad4x4x4d_sse2;
-    vpx_sad4x4x8 = vpx_sad4x4x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad4x4x8 = vpx_sad4x4x8_sse4_1;
-    vpx_sad4x8 = vpx_sad4x8_c;
-    if (flags & HAS_SSE2) vpx_sad4x8 = vpx_sad4x8_sse2;
-    vpx_sad4x8_avg = vpx_sad4x8_avg_c;
-    if (flags & HAS_SSE2) vpx_sad4x8_avg = vpx_sad4x8_avg_sse2;
-    vpx_sad4x8x4d = vpx_sad4x8x4d_c;
-    if (flags & HAS_SSE2) vpx_sad4x8x4d = vpx_sad4x8x4d_sse2;
-    vpx_sad64x32 = vpx_sad64x32_c;
-    if (flags & HAS_SSE2) vpx_sad64x32 = vpx_sad64x32_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x32 = vpx_sad64x32_avx2;
-    vpx_sad64x32_avg = vpx_sad64x32_avg_c;
-    if (flags & HAS_SSE2) vpx_sad64x32_avg = vpx_sad64x32_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x32_avg = vpx_sad64x32_avg_avx2;
-    vpx_sad64x32x4d = vpx_sad64x32x4d_c;
-    if (flags & HAS_SSE2) vpx_sad64x32x4d = vpx_sad64x32x4d_sse2;
-    vpx_sad64x64 = vpx_sad64x64_c;
-    if (flags & HAS_SSE2) vpx_sad64x64 = vpx_sad64x64_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64 = vpx_sad64x64_avx2;
-    vpx_sad64x64_avg = vpx_sad64x64_avg_c;
-    if (flags & HAS_SSE2) vpx_sad64x64_avg = vpx_sad64x64_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64_avg = vpx_sad64x64_avg_avx2;
-    vpx_sad64x64x4d = vpx_sad64x64x4d_c;
-    if (flags & HAS_SSE2) vpx_sad64x64x4d = vpx_sad64x64x4d_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64x4d = vpx_sad64x64x4d_avx2;
-    vpx_sad8x16 = vpx_sad8x16_c;
-    if (flags & HAS_SSE2) vpx_sad8x16 = vpx_sad8x16_sse2;
-    vpx_sad8x16_avg = vpx_sad8x16_avg_c;
-    if (flags & HAS_SSE2) vpx_sad8x16_avg = vpx_sad8x16_avg_sse2;
-    vpx_sad8x16x3 = vpx_sad8x16x3_c;
-    if (flags & HAS_SSE3) vpx_sad8x16x3 = vpx_sad8x16x3_sse3;
-    vpx_sad8x16x4d = vpx_sad8x16x4d_c;
-    if (flags & HAS_SSE2) vpx_sad8x16x4d = vpx_sad8x16x4d_sse2;
-    vpx_sad8x16x8 = vpx_sad8x16x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad8x16x8 = vpx_sad8x16x8_sse4_1;
-    vpx_sad8x4 = vpx_sad8x4_c;
-    if (flags & HAS_SSE2) vpx_sad8x4 = vpx_sad8x4_sse2;
-    vpx_sad8x4_avg = vpx_sad8x4_avg_c;
-    if (flags & HAS_SSE2) vpx_sad8x4_avg = vpx_sad8x4_avg_sse2;
-    vpx_sad8x4x4d = vpx_sad8x4x4d_c;
-    if (flags & HAS_SSE2) vpx_sad8x4x4d = vpx_sad8x4x4d_sse2;
-    vpx_sad8x8 = vpx_sad8x8_c;
-    if (flags & HAS_SSE2) vpx_sad8x8 = vpx_sad8x8_sse2;
-    vpx_sad8x8_avg = vpx_sad8x8_avg_c;
-    if (flags & HAS_SSE2) vpx_sad8x8_avg = vpx_sad8x8_avg_sse2;
-    vpx_sad8x8x3 = vpx_sad8x8x3_c;
-    if (flags & HAS_SSE3) vpx_sad8x8x3 = vpx_sad8x8x3_sse3;
-    vpx_sad8x8x4d = vpx_sad8x8x4d_c;
-    if (flags & HAS_SSE2) vpx_sad8x8x4d = vpx_sad8x8x4d_sse2;
-    vpx_sad8x8x8 = vpx_sad8x8x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad8x8x8 = vpx_sad8x8x8_sse4_1;
-    vpx_satd = vpx_satd_c;
-    if (flags & HAS_SSE2) vpx_satd = vpx_satd_sse2;
-    vpx_scaled_2d = vpx_scaled_2d_c;
-    if (flags & HAS_SSSE3) vpx_scaled_2d = vpx_scaled_2d_ssse3;
-    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_ssse3;
-    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_ssse3;
-    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_ssse3;
-    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_ssse3;
-    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_avx2;
-    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_ssse3;
-    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_ssse3;
-    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_ssse3;
-    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_ssse3;
-    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_avx2;
-    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_ssse3;
-    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_ssse3;
-    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_ssse3;
-    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_ssse3;
-    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_ssse3;
-    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_ssse3;
-    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_ssse3;
-    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_avx2;
-    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_ssse3;
-    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_ssse3;
-    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_ssse3;
-    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_ssse3;
-    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_avx2;
-    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_ssse3;
-    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_ssse3;
-    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_ssse3;
-    vpx_subtract_block = vpx_subtract_block_c;
-    if (flags & HAS_SSE2) vpx_subtract_block = vpx_subtract_block_sse2;
-    vpx_sum_squares_2d_i16 = vpx_sum_squares_2d_i16_c;
-    if (flags & HAS_SSE2) vpx_sum_squares_2d_i16 = vpx_sum_squares_2d_i16_sse2;
-    vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_sse2;
-    vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_sse2;
-    vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_sse2;
-    vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_sse2;
-    vpx_v_predictor_16x16 = vpx_v_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_v_predictor_16x16 = vpx_v_predictor_16x16_sse2;
-    vpx_v_predictor_32x32 = vpx_v_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_v_predictor_32x32 = vpx_v_predictor_32x32_sse2;
-    vpx_v_predictor_4x4 = vpx_v_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_v_predictor_4x4 = vpx_v_predictor_4x4_sse2;
-    vpx_v_predictor_8x8 = vpx_v_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_v_predictor_8x8 = vpx_v_predictor_8x8_sse2;
-    vpx_variance16x16 = vpx_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_variance16x16 = vpx_variance16x16_sse2;
-    if (flags & HAS_AVX2) vpx_variance16x16 = vpx_variance16x16_avx2;
-    vpx_variance16x32 = vpx_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_variance16x32 = vpx_variance16x32_sse2;
-    vpx_variance16x8 = vpx_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_variance16x8 = vpx_variance16x8_sse2;
-    vpx_variance32x16 = vpx_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_variance32x16 = vpx_variance32x16_sse2;
-    if (flags & HAS_AVX2) vpx_variance32x16 = vpx_variance32x16_avx2;
-    vpx_variance32x32 = vpx_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_variance32x32 = vpx_variance32x32_sse2;
-    if (flags & HAS_AVX2) vpx_variance32x32 = vpx_variance32x32_avx2;
-    vpx_variance32x64 = vpx_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_variance32x64 = vpx_variance32x64_sse2;
-    vpx_variance4x4 = vpx_variance4x4_c;
-    if (flags & HAS_SSE2) vpx_variance4x4 = vpx_variance4x4_sse2;
-    vpx_variance4x8 = vpx_variance4x8_c;
-    if (flags & HAS_SSE2) vpx_variance4x8 = vpx_variance4x8_sse2;
-    vpx_variance64x32 = vpx_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_variance64x32 = vpx_variance64x32_sse2;
-    if (flags & HAS_AVX2) vpx_variance64x32 = vpx_variance64x32_avx2;
-    vpx_variance64x64 = vpx_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_variance64x64 = vpx_variance64x64_sse2;
-    if (flags & HAS_AVX2) vpx_variance64x64 = vpx_variance64x64_avx2;
-    vpx_variance8x16 = vpx_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_variance8x16 = vpx_variance8x16_sse2;
-    vpx_variance8x4 = vpx_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_variance8x4 = vpx_variance8x4_sse2;
-    vpx_variance8x8 = vpx_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_variance8x8 = vpx_variance8x8_sse2;
-    vpx_vector_var = vpx_vector_var_c;
-    if (flags & HAS_SSE2) vpx_vector_var = vpx_vector_var_sse2;
+  vpx_avg_4x4 = vpx_avg_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_avg_4x4 = vpx_avg_4x4_sse2;
+  vpx_avg_8x8 = vpx_avg_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_avg_8x8 = vpx_avg_8x8_sse2;
+  vpx_comp_avg_pred = vpx_comp_avg_pred_c;
+  if (flags & HAS_SSE2)
+    vpx_comp_avg_pred = vpx_comp_avg_pred_sse2;
+  vpx_convolve8 = vpx_convolve8_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8 = vpx_convolve8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8 = vpx_convolve8_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8 = vpx_convolve8_avx2;
+  vpx_convolve8_avg = vpx_convolve8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_avg = vpx_convolve8_avg_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg = vpx_convolve8_avg_ssse3;
+  vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_ssse3;
+  vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_ssse3;
+  vpx_convolve8_horiz = vpx_convolve8_horiz_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_avx2;
+  vpx_convolve8_vert = vpx_convolve8_vert_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_vert = vpx_convolve8_vert_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_vert = vpx_convolve8_vert_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8_vert = vpx_convolve8_vert_avx2;
+  vpx_convolve_avg = vpx_convolve_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve_avg = vpx_convolve_avg_sse2;
+  vpx_convolve_copy = vpx_convolve_copy_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve_copy = vpx_convolve_copy_sse2;
+  vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_ssse3;
+  vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_ssse3;
+  vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_ssse3;
+  vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_ssse3;
+  vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_ssse3;
+  vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_ssse3;
+  vpx_d207_predictor_4x4 = vpx_d207_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_d207_predictor_4x4 = vpx_d207_predictor_4x4_sse2;
+  vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_ssse3;
+  vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_ssse3;
+  vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_ssse3;
+  vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_sse2;
+  vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_sse2;
+  vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_ssse3;
+  vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_ssse3;
+  vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_ssse3;
+  vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_ssse3;
+  vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_sse2;
+  vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_sse2;
+  vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_sse2;
+  vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_sse2;
+  vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_sse2;
+  vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_sse2;
+  vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_sse2;
+  vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_sse2;
+  vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_sse2;
+  vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_sse2;
+  vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_sse2;
+  vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_sse2;
+  vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_sse2;
+  vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_sse2;
+  vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_sse2;
+  vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_sse2;
+  vpx_fdct16x16 = vpx_fdct16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct16x16 = vpx_fdct16x16_sse2;
+  vpx_fdct16x16_1 = vpx_fdct16x16_1_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct16x16_1 = vpx_fdct16x16_1_sse2;
+  vpx_fdct32x32 = vpx_fdct32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct32x32 = vpx_fdct32x32_sse2;
+  vpx_fdct32x32_1 = vpx_fdct32x32_1_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct32x32_1 = vpx_fdct32x32_1_sse2;
+  vpx_fdct32x32_rd = vpx_fdct32x32_rd_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct32x32_rd = vpx_fdct32x32_rd_sse2;
+  vpx_fdct4x4 = vpx_fdct4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct4x4 = vpx_fdct4x4_sse2;
+  vpx_fdct4x4_1 = vpx_fdct4x4_1_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct4x4_1 = vpx_fdct4x4_1_sse2;
+  vpx_fdct8x8 = vpx_fdct8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct8x8 = vpx_fdct8x8_sse2;
+  vpx_fdct8x8_1 = vpx_fdct8x8_1_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct8x8_1 = vpx_fdct8x8_1_sse2;
+  vpx_get16x16var = vpx_get16x16var_c;
+  if (flags & HAS_SSE2)
+    vpx_get16x16var = vpx_get16x16var_sse2;
+  if (flags & HAS_AVX2)
+    vpx_get16x16var = vpx_get16x16var_avx2;
+  vpx_get8x8var = vpx_get8x8var_c;
+  if (flags & HAS_SSE2)
+    vpx_get8x8var = vpx_get8x8var_sse2;
+  vpx_get_mb_ss = vpx_get_mb_ss_c;
+  if (flags & HAS_SSE2)
+    vpx_get_mb_ss = vpx_get_mb_ss_sse2;
+  vpx_h_predictor_16x16 = vpx_h_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_h_predictor_16x16 = vpx_h_predictor_16x16_sse2;
+  vpx_h_predictor_32x32 = vpx_h_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_h_predictor_32x32 = vpx_h_predictor_32x32_sse2;
+  vpx_h_predictor_4x4 = vpx_h_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_h_predictor_4x4 = vpx_h_predictor_4x4_sse2;
+  vpx_h_predictor_8x8 = vpx_h_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_h_predictor_8x8 = vpx_h_predictor_8x8_sse2;
+  vpx_hadamard_16x16 = vpx_hadamard_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_hadamard_16x16 = vpx_hadamard_16x16_sse2;
+  vpx_hadamard_8x8 = vpx_hadamard_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_hadamard_8x8 = vpx_hadamard_8x8_sse2;
+  vpx_highbd_10_mse16x16 = vpx_highbd_10_mse16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_mse16x16 = vpx_highbd_10_mse16x16_sse2;
+  vpx_highbd_10_mse8x8 = vpx_highbd_10_mse8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_mse8x8 = vpx_highbd_10_mse8x8_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance16x16 =
+      vpx_highbd_10_sub_pixel_avg_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance16x16 =
+        vpx_highbd_10_sub_pixel_avg_variance16x16_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance16x32 =
+      vpx_highbd_10_sub_pixel_avg_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance16x32 =
+        vpx_highbd_10_sub_pixel_avg_variance16x32_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance16x8 =
+      vpx_highbd_10_sub_pixel_avg_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance16x8 =
+        vpx_highbd_10_sub_pixel_avg_variance16x8_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance32x16 =
+      vpx_highbd_10_sub_pixel_avg_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance32x16 =
+        vpx_highbd_10_sub_pixel_avg_variance32x16_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance32x32 =
+      vpx_highbd_10_sub_pixel_avg_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance32x32 =
+        vpx_highbd_10_sub_pixel_avg_variance32x32_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance32x64 =
+      vpx_highbd_10_sub_pixel_avg_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance32x64 =
+        vpx_highbd_10_sub_pixel_avg_variance32x64_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance64x32 =
+      vpx_highbd_10_sub_pixel_avg_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance64x32 =
+        vpx_highbd_10_sub_pixel_avg_variance64x32_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance64x64 =
+      vpx_highbd_10_sub_pixel_avg_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance64x64 =
+        vpx_highbd_10_sub_pixel_avg_variance64x64_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance8x16 =
+      vpx_highbd_10_sub_pixel_avg_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance8x16 =
+        vpx_highbd_10_sub_pixel_avg_variance8x16_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance8x4 =
+      vpx_highbd_10_sub_pixel_avg_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance8x4 =
+        vpx_highbd_10_sub_pixel_avg_variance8x4_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance8x8 =
+      vpx_highbd_10_sub_pixel_avg_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance8x8 =
+        vpx_highbd_10_sub_pixel_avg_variance8x8_sse2;
+  vpx_highbd_10_sub_pixel_variance16x16 =
+      vpx_highbd_10_sub_pixel_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance16x16 =
+        vpx_highbd_10_sub_pixel_variance16x16_sse2;
+  vpx_highbd_10_sub_pixel_variance16x32 =
+      vpx_highbd_10_sub_pixel_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance16x32 =
+        vpx_highbd_10_sub_pixel_variance16x32_sse2;
+  vpx_highbd_10_sub_pixel_variance16x8 = vpx_highbd_10_sub_pixel_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance16x8 =
+        vpx_highbd_10_sub_pixel_variance16x8_sse2;
+  vpx_highbd_10_sub_pixel_variance32x16 =
+      vpx_highbd_10_sub_pixel_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance32x16 =
+        vpx_highbd_10_sub_pixel_variance32x16_sse2;
+  vpx_highbd_10_sub_pixel_variance32x32 =
+      vpx_highbd_10_sub_pixel_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance32x32 =
+        vpx_highbd_10_sub_pixel_variance32x32_sse2;
+  vpx_highbd_10_sub_pixel_variance32x64 =
+      vpx_highbd_10_sub_pixel_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance32x64 =
+        vpx_highbd_10_sub_pixel_variance32x64_sse2;
+  vpx_highbd_10_sub_pixel_variance64x32 =
+      vpx_highbd_10_sub_pixel_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance64x32 =
+        vpx_highbd_10_sub_pixel_variance64x32_sse2;
+  vpx_highbd_10_sub_pixel_variance64x64 =
+      vpx_highbd_10_sub_pixel_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance64x64 =
+        vpx_highbd_10_sub_pixel_variance64x64_sse2;
+  vpx_highbd_10_sub_pixel_variance8x16 = vpx_highbd_10_sub_pixel_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance8x16 =
+        vpx_highbd_10_sub_pixel_variance8x16_sse2;
+  vpx_highbd_10_sub_pixel_variance8x4 = vpx_highbd_10_sub_pixel_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance8x4 =
+        vpx_highbd_10_sub_pixel_variance8x4_sse2;
+  vpx_highbd_10_sub_pixel_variance8x8 = vpx_highbd_10_sub_pixel_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance8x8 =
+        vpx_highbd_10_sub_pixel_variance8x8_sse2;
+  vpx_highbd_10_variance16x16 = vpx_highbd_10_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance16x16 = vpx_highbd_10_variance16x16_sse2;
+  vpx_highbd_10_variance16x32 = vpx_highbd_10_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance16x32 = vpx_highbd_10_variance16x32_sse2;
+  vpx_highbd_10_variance16x8 = vpx_highbd_10_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance16x8 = vpx_highbd_10_variance16x8_sse2;
+  vpx_highbd_10_variance32x16 = vpx_highbd_10_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance32x16 = vpx_highbd_10_variance32x16_sse2;
+  vpx_highbd_10_variance32x32 = vpx_highbd_10_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance32x32 = vpx_highbd_10_variance32x32_sse2;
+  vpx_highbd_10_variance32x64 = vpx_highbd_10_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance32x64 = vpx_highbd_10_variance32x64_sse2;
+  vpx_highbd_10_variance64x32 = vpx_highbd_10_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance64x32 = vpx_highbd_10_variance64x32_sse2;
+  vpx_highbd_10_variance64x64 = vpx_highbd_10_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance64x64 = vpx_highbd_10_variance64x64_sse2;
+  vpx_highbd_10_variance8x16 = vpx_highbd_10_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance8x16 = vpx_highbd_10_variance8x16_sse2;
+  vpx_highbd_10_variance8x8 = vpx_highbd_10_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance8x8 = vpx_highbd_10_variance8x8_sse2;
+  vpx_highbd_12_mse16x16 = vpx_highbd_12_mse16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_mse16x16 = vpx_highbd_12_mse16x16_sse2;
+  vpx_highbd_12_mse8x8 = vpx_highbd_12_mse8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_mse8x8 = vpx_highbd_12_mse8x8_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance16x16 =
+      vpx_highbd_12_sub_pixel_avg_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance16x16 =
+        vpx_highbd_12_sub_pixel_avg_variance16x16_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance16x32 =
+      vpx_highbd_12_sub_pixel_avg_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance16x32 =
+        vpx_highbd_12_sub_pixel_avg_variance16x32_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance16x8 =
+      vpx_highbd_12_sub_pixel_avg_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance16x8 =
+        vpx_highbd_12_sub_pixel_avg_variance16x8_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance32x16 =
+      vpx_highbd_12_sub_pixel_avg_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance32x16 =
+        vpx_highbd_12_sub_pixel_avg_variance32x16_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance32x32 =
+      vpx_highbd_12_sub_pixel_avg_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance32x32 =
+        vpx_highbd_12_sub_pixel_avg_variance32x32_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance32x64 =
+      vpx_highbd_12_sub_pixel_avg_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance32x64 =
+        vpx_highbd_12_sub_pixel_avg_variance32x64_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance64x32 =
+      vpx_highbd_12_sub_pixel_avg_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance64x32 =
+        vpx_highbd_12_sub_pixel_avg_variance64x32_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance64x64 =
+      vpx_highbd_12_sub_pixel_avg_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance64x64 =
+        vpx_highbd_12_sub_pixel_avg_variance64x64_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance8x16 =
+      vpx_highbd_12_sub_pixel_avg_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance8x16 =
+        vpx_highbd_12_sub_pixel_avg_variance8x16_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance8x4 =
+      vpx_highbd_12_sub_pixel_avg_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance8x4 =
+        vpx_highbd_12_sub_pixel_avg_variance8x4_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance8x8 =
+      vpx_highbd_12_sub_pixel_avg_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance8x8 =
+        vpx_highbd_12_sub_pixel_avg_variance8x8_sse2;
+  vpx_highbd_12_sub_pixel_variance16x16 =
+      vpx_highbd_12_sub_pixel_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance16x16 =
+        vpx_highbd_12_sub_pixel_variance16x16_sse2;
+  vpx_highbd_12_sub_pixel_variance16x32 =
+      vpx_highbd_12_sub_pixel_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance16x32 =
+        vpx_highbd_12_sub_pixel_variance16x32_sse2;
+  vpx_highbd_12_sub_pixel_variance16x8 = vpx_highbd_12_sub_pixel_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance16x8 =
+        vpx_highbd_12_sub_pixel_variance16x8_sse2;
+  vpx_highbd_12_sub_pixel_variance32x16 =
+      vpx_highbd_12_sub_pixel_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance32x16 =
+        vpx_highbd_12_sub_pixel_variance32x16_sse2;
+  vpx_highbd_12_sub_pixel_variance32x32 =
+      vpx_highbd_12_sub_pixel_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance32x32 =
+        vpx_highbd_12_sub_pixel_variance32x32_sse2;
+  vpx_highbd_12_sub_pixel_variance32x64 =
+      vpx_highbd_12_sub_pixel_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance32x64 =
+        vpx_highbd_12_sub_pixel_variance32x64_sse2;
+  vpx_highbd_12_sub_pixel_variance64x32 =
+      vpx_highbd_12_sub_pixel_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance64x32 =
+        vpx_highbd_12_sub_pixel_variance64x32_sse2;
+  vpx_highbd_12_sub_pixel_variance64x64 =
+      vpx_highbd_12_sub_pixel_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance64x64 =
+        vpx_highbd_12_sub_pixel_variance64x64_sse2;
+  vpx_highbd_12_sub_pixel_variance8x16 = vpx_highbd_12_sub_pixel_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance8x16 =
+        vpx_highbd_12_sub_pixel_variance8x16_sse2;
+  vpx_highbd_12_sub_pixel_variance8x4 = vpx_highbd_12_sub_pixel_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance8x4 =
+        vpx_highbd_12_sub_pixel_variance8x4_sse2;
+  vpx_highbd_12_sub_pixel_variance8x8 = vpx_highbd_12_sub_pixel_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance8x8 =
+        vpx_highbd_12_sub_pixel_variance8x8_sse2;
+  vpx_highbd_12_variance16x16 = vpx_highbd_12_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance16x16 = vpx_highbd_12_variance16x16_sse2;
+  vpx_highbd_12_variance16x32 = vpx_highbd_12_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance16x32 = vpx_highbd_12_variance16x32_sse2;
+  vpx_highbd_12_variance16x8 = vpx_highbd_12_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance16x8 = vpx_highbd_12_variance16x8_sse2;
+  vpx_highbd_12_variance32x16 = vpx_highbd_12_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance32x16 = vpx_highbd_12_variance32x16_sse2;
+  vpx_highbd_12_variance32x32 = vpx_highbd_12_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance32x32 = vpx_highbd_12_variance32x32_sse2;
+  vpx_highbd_12_variance32x64 = vpx_highbd_12_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance32x64 = vpx_highbd_12_variance32x64_sse2;
+  vpx_highbd_12_variance64x32 = vpx_highbd_12_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance64x32 = vpx_highbd_12_variance64x32_sse2;
+  vpx_highbd_12_variance64x64 = vpx_highbd_12_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance64x64 = vpx_highbd_12_variance64x64_sse2;
+  vpx_highbd_12_variance8x16 = vpx_highbd_12_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance8x16 = vpx_highbd_12_variance8x16_sse2;
+  vpx_highbd_12_variance8x8 = vpx_highbd_12_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance8x8 = vpx_highbd_12_variance8x8_sse2;
+  vpx_highbd_8_mse16x16 = vpx_highbd_8_mse16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_mse16x16 = vpx_highbd_8_mse16x16_sse2;
+  vpx_highbd_8_mse8x8 = vpx_highbd_8_mse8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_mse8x8 = vpx_highbd_8_mse8x8_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance16x16 =
+      vpx_highbd_8_sub_pixel_avg_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance16x16 =
+        vpx_highbd_8_sub_pixel_avg_variance16x16_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance16x32 =
+      vpx_highbd_8_sub_pixel_avg_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance16x32 =
+        vpx_highbd_8_sub_pixel_avg_variance16x32_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance16x8 =
+      vpx_highbd_8_sub_pixel_avg_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance16x8 =
+        vpx_highbd_8_sub_pixel_avg_variance16x8_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance32x16 =
+      vpx_highbd_8_sub_pixel_avg_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance32x16 =
+        vpx_highbd_8_sub_pixel_avg_variance32x16_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance32x32 =
+      vpx_highbd_8_sub_pixel_avg_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance32x32 =
+        vpx_highbd_8_sub_pixel_avg_variance32x32_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance32x64 =
+      vpx_highbd_8_sub_pixel_avg_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance32x64 =
+        vpx_highbd_8_sub_pixel_avg_variance32x64_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance64x32 =
+      vpx_highbd_8_sub_pixel_avg_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance64x32 =
+        vpx_highbd_8_sub_pixel_avg_variance64x32_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance64x64 =
+      vpx_highbd_8_sub_pixel_avg_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance64x64 =
+        vpx_highbd_8_sub_pixel_avg_variance64x64_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance8x16 =
+      vpx_highbd_8_sub_pixel_avg_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance8x16 =
+        vpx_highbd_8_sub_pixel_avg_variance8x16_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance8x4 =
+      vpx_highbd_8_sub_pixel_avg_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance8x4 =
+        vpx_highbd_8_sub_pixel_avg_variance8x4_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance8x8 =
+      vpx_highbd_8_sub_pixel_avg_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance8x8 =
+        vpx_highbd_8_sub_pixel_avg_variance8x8_sse2;
+  vpx_highbd_8_sub_pixel_variance16x16 = vpx_highbd_8_sub_pixel_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance16x16 =
+        vpx_highbd_8_sub_pixel_variance16x16_sse2;
+  vpx_highbd_8_sub_pixel_variance16x32 = vpx_highbd_8_sub_pixel_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance16x32 =
+        vpx_highbd_8_sub_pixel_variance16x32_sse2;
+  vpx_highbd_8_sub_pixel_variance16x8 = vpx_highbd_8_sub_pixel_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance16x8 =
+        vpx_highbd_8_sub_pixel_variance16x8_sse2;
+  vpx_highbd_8_sub_pixel_variance32x16 = vpx_highbd_8_sub_pixel_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance32x16 =
+        vpx_highbd_8_sub_pixel_variance32x16_sse2;
+  vpx_highbd_8_sub_pixel_variance32x32 = vpx_highbd_8_sub_pixel_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance32x32 =
+        vpx_highbd_8_sub_pixel_variance32x32_sse2;
+  vpx_highbd_8_sub_pixel_variance32x64 = vpx_highbd_8_sub_pixel_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance32x64 =
+        vpx_highbd_8_sub_pixel_variance32x64_sse2;
+  vpx_highbd_8_sub_pixel_variance64x32 = vpx_highbd_8_sub_pixel_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance64x32 =
+        vpx_highbd_8_sub_pixel_variance64x32_sse2;
+  vpx_highbd_8_sub_pixel_variance64x64 = vpx_highbd_8_sub_pixel_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance64x64 =
+        vpx_highbd_8_sub_pixel_variance64x64_sse2;
+  vpx_highbd_8_sub_pixel_variance8x16 = vpx_highbd_8_sub_pixel_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance8x16 =
+        vpx_highbd_8_sub_pixel_variance8x16_sse2;
+  vpx_highbd_8_sub_pixel_variance8x4 = vpx_highbd_8_sub_pixel_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance8x4 =
+        vpx_highbd_8_sub_pixel_variance8x4_sse2;
+  vpx_highbd_8_sub_pixel_variance8x8 = vpx_highbd_8_sub_pixel_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance8x8 =
+        vpx_highbd_8_sub_pixel_variance8x8_sse2;
+  vpx_highbd_8_variance16x16 = vpx_highbd_8_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance16x16 = vpx_highbd_8_variance16x16_sse2;
+  vpx_highbd_8_variance16x32 = vpx_highbd_8_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance16x32 = vpx_highbd_8_variance16x32_sse2;
+  vpx_highbd_8_variance16x8 = vpx_highbd_8_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance16x8 = vpx_highbd_8_variance16x8_sse2;
+  vpx_highbd_8_variance32x16 = vpx_highbd_8_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance32x16 = vpx_highbd_8_variance32x16_sse2;
+  vpx_highbd_8_variance32x32 = vpx_highbd_8_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance32x32 = vpx_highbd_8_variance32x32_sse2;
+  vpx_highbd_8_variance32x64 = vpx_highbd_8_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance32x64 = vpx_highbd_8_variance32x64_sse2;
+  vpx_highbd_8_variance64x32 = vpx_highbd_8_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance64x32 = vpx_highbd_8_variance64x32_sse2;
+  vpx_highbd_8_variance64x64 = vpx_highbd_8_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance64x64 = vpx_highbd_8_variance64x64_sse2;
+  vpx_highbd_8_variance8x16 = vpx_highbd_8_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance8x16 = vpx_highbd_8_variance8x16_sse2;
+  vpx_highbd_8_variance8x8 = vpx_highbd_8_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance8x8 = vpx_highbd_8_variance8x8_sse2;
+  vpx_highbd_convolve8 = vpx_highbd_convolve8_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8 = vpx_highbd_convolve8_avx2;
+  vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_avx2;
+  vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_avx2;
+  vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_avx2;
+  vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_avx2;
+  vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_avx2;
+  vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_avx2;
+  vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_avx2;
+  vpx_highbd_dc_predictor_16x16 = vpx_highbd_dc_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_dc_predictor_16x16 = vpx_highbd_dc_predictor_16x16_sse2;
+  vpx_highbd_dc_predictor_32x32 = vpx_highbd_dc_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_dc_predictor_32x32 = vpx_highbd_dc_predictor_32x32_sse2;
+  vpx_highbd_dc_predictor_4x4 = vpx_highbd_dc_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_dc_predictor_4x4 = vpx_highbd_dc_predictor_4x4_sse2;
+  vpx_highbd_dc_predictor_8x8 = vpx_highbd_dc_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_dc_predictor_8x8 = vpx_highbd_dc_predictor_8x8_sse2;
+  vpx_highbd_fdct16x16 = vpx_highbd_fdct16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct16x16 = vpx_highbd_fdct16x16_sse2;
+  vpx_highbd_fdct32x32 = vpx_highbd_fdct32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct32x32 = vpx_highbd_fdct32x32_sse2;
+  vpx_highbd_fdct32x32_rd = vpx_highbd_fdct32x32_rd_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct32x32_rd = vpx_highbd_fdct32x32_rd_sse2;
+  vpx_highbd_fdct4x4 = vpx_highbd_fdct4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct4x4 = vpx_highbd_fdct4x4_sse2;
+  vpx_highbd_fdct8x8 = vpx_highbd_fdct8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct8x8 = vpx_highbd_fdct8x8_sse2;
+  vpx_highbd_idct16x16_10_add = vpx_highbd_idct16x16_10_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct16x16_10_add = vpx_highbd_idct16x16_10_add_sse2;
+  vpx_highbd_idct16x16_1_add = vpx_highbd_idct16x16_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct16x16_1_add = vpx_highbd_idct16x16_1_add_sse2;
+  vpx_highbd_idct16x16_256_add = vpx_highbd_idct16x16_256_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct16x16_256_add = vpx_highbd_idct16x16_256_add_sse2;
+  vpx_highbd_idct16x16_38_add = vpx_highbd_idct16x16_38_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct16x16_38_add = vpx_highbd_idct16x16_38_add_sse2;
+  vpx_highbd_idct32x32_1_add = vpx_highbd_idct32x32_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct32x32_1_add = vpx_highbd_idct32x32_1_add_sse2;
+  vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse4_1;
+  vpx_highbd_idct4x4_1_add = vpx_highbd_idct4x4_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct4x4_1_add = vpx_highbd_idct4x4_1_add_sse2;
+  vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse4_1;
+  vpx_highbd_idct8x8_1_add = vpx_highbd_idct8x8_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct8x8_1_add = vpx_highbd_idct8x8_1_add_sse2;
+  vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse4_1;
+  vpx_highbd_lpf_horizontal_16 = vpx_highbd_lpf_horizontal_16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_16 = vpx_highbd_lpf_horizontal_16_sse2;
+  vpx_highbd_lpf_horizontal_16_dual = vpx_highbd_lpf_horizontal_16_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_16_dual = vpx_highbd_lpf_horizontal_16_dual_sse2;
+  vpx_highbd_lpf_horizontal_4 = vpx_highbd_lpf_horizontal_4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_4 = vpx_highbd_lpf_horizontal_4_sse2;
+  vpx_highbd_lpf_horizontal_4_dual = vpx_highbd_lpf_horizontal_4_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_4_dual = vpx_highbd_lpf_horizontal_4_dual_sse2;
+  vpx_highbd_lpf_horizontal_8 = vpx_highbd_lpf_horizontal_8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_8 = vpx_highbd_lpf_horizontal_8_sse2;
+  vpx_highbd_lpf_horizontal_8_dual = vpx_highbd_lpf_horizontal_8_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_8_dual = vpx_highbd_lpf_horizontal_8_dual_sse2;
+  vpx_highbd_lpf_vertical_16 = vpx_highbd_lpf_vertical_16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_16 = vpx_highbd_lpf_vertical_16_sse2;
+  vpx_highbd_lpf_vertical_16_dual = vpx_highbd_lpf_vertical_16_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_16_dual = vpx_highbd_lpf_vertical_16_dual_sse2;
+  vpx_highbd_lpf_vertical_4 = vpx_highbd_lpf_vertical_4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_4 = vpx_highbd_lpf_vertical_4_sse2;
+  vpx_highbd_lpf_vertical_4_dual = vpx_highbd_lpf_vertical_4_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_4_dual = vpx_highbd_lpf_vertical_4_dual_sse2;
+  vpx_highbd_lpf_vertical_8 = vpx_highbd_lpf_vertical_8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_8 = vpx_highbd_lpf_vertical_8_sse2;
+  vpx_highbd_lpf_vertical_8_dual = vpx_highbd_lpf_vertical_8_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_8_dual = vpx_highbd_lpf_vertical_8_dual_sse2;
+  vpx_highbd_quantize_b = vpx_highbd_quantize_b_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_quantize_b = vpx_highbd_quantize_b_sse2;
+  vpx_highbd_quantize_b_32x32 = vpx_highbd_quantize_b_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_quantize_b_32x32 = vpx_highbd_quantize_b_32x32_sse2;
+  vpx_highbd_sad16x16 = vpx_highbd_sad16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x16 = vpx_highbd_sad16x16_sse2;
+  vpx_highbd_sad16x16_avg = vpx_highbd_sad16x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x16_avg = vpx_highbd_sad16x16_avg_sse2;
+  vpx_highbd_sad16x16x4d = vpx_highbd_sad16x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x16x4d = vpx_highbd_sad16x16x4d_sse2;
+  vpx_highbd_sad16x32 = vpx_highbd_sad16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x32 = vpx_highbd_sad16x32_sse2;
+  vpx_highbd_sad16x32_avg = vpx_highbd_sad16x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x32_avg = vpx_highbd_sad16x32_avg_sse2;
+  vpx_highbd_sad16x32x4d = vpx_highbd_sad16x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x32x4d = vpx_highbd_sad16x32x4d_sse2;
+  vpx_highbd_sad16x8 = vpx_highbd_sad16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x8 = vpx_highbd_sad16x8_sse2;
+  vpx_highbd_sad16x8_avg = vpx_highbd_sad16x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x8_avg = vpx_highbd_sad16x8_avg_sse2;
+  vpx_highbd_sad16x8x4d = vpx_highbd_sad16x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x8x4d = vpx_highbd_sad16x8x4d_sse2;
+  vpx_highbd_sad32x16 = vpx_highbd_sad32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x16 = vpx_highbd_sad32x16_sse2;
+  vpx_highbd_sad32x16_avg = vpx_highbd_sad32x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x16_avg = vpx_highbd_sad32x16_avg_sse2;
+  vpx_highbd_sad32x16x4d = vpx_highbd_sad32x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x16x4d = vpx_highbd_sad32x16x4d_sse2;
+  vpx_highbd_sad32x32 = vpx_highbd_sad32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x32 = vpx_highbd_sad32x32_sse2;
+  vpx_highbd_sad32x32_avg = vpx_highbd_sad32x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x32_avg = vpx_highbd_sad32x32_avg_sse2;
+  vpx_highbd_sad32x32x4d = vpx_highbd_sad32x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x32x4d = vpx_highbd_sad32x32x4d_sse2;
+  vpx_highbd_sad32x64 = vpx_highbd_sad32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x64 = vpx_highbd_sad32x64_sse2;
+  vpx_highbd_sad32x64_avg = vpx_highbd_sad32x64_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x64_avg = vpx_highbd_sad32x64_avg_sse2;
+  vpx_highbd_sad32x64x4d = vpx_highbd_sad32x64x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x64x4d = vpx_highbd_sad32x64x4d_sse2;
+  vpx_highbd_sad4x4x4d = vpx_highbd_sad4x4x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad4x4x4d = vpx_highbd_sad4x4x4d_sse2;
+  vpx_highbd_sad4x8x4d = vpx_highbd_sad4x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad4x8x4d = vpx_highbd_sad4x8x4d_sse2;
+  vpx_highbd_sad64x32 = vpx_highbd_sad64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x32 = vpx_highbd_sad64x32_sse2;
+  vpx_highbd_sad64x32_avg = vpx_highbd_sad64x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x32_avg = vpx_highbd_sad64x32_avg_sse2;
+  vpx_highbd_sad64x32x4d = vpx_highbd_sad64x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x32x4d = vpx_highbd_sad64x32x4d_sse2;
+  vpx_highbd_sad64x64 = vpx_highbd_sad64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x64 = vpx_highbd_sad64x64_sse2;
+  vpx_highbd_sad64x64_avg = vpx_highbd_sad64x64_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x64_avg = vpx_highbd_sad64x64_avg_sse2;
+  vpx_highbd_sad64x64x4d = vpx_highbd_sad64x64x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x64x4d = vpx_highbd_sad64x64x4d_sse2;
+  vpx_highbd_sad8x16 = vpx_highbd_sad8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x16 = vpx_highbd_sad8x16_sse2;
+  vpx_highbd_sad8x16_avg = vpx_highbd_sad8x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x16_avg = vpx_highbd_sad8x16_avg_sse2;
+  vpx_highbd_sad8x16x4d = vpx_highbd_sad8x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x16x4d = vpx_highbd_sad8x16x4d_sse2;
+  vpx_highbd_sad8x4 = vpx_highbd_sad8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x4 = vpx_highbd_sad8x4_sse2;
+  vpx_highbd_sad8x4_avg = vpx_highbd_sad8x4_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x4_avg = vpx_highbd_sad8x4_avg_sse2;
+  vpx_highbd_sad8x4x4d = vpx_highbd_sad8x4x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x4x4d = vpx_highbd_sad8x4x4d_sse2;
+  vpx_highbd_sad8x8 = vpx_highbd_sad8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x8 = vpx_highbd_sad8x8_sse2;
+  vpx_highbd_sad8x8_avg = vpx_highbd_sad8x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x8_avg = vpx_highbd_sad8x8_avg_sse2;
+  vpx_highbd_sad8x8x4d = vpx_highbd_sad8x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x8x4d = vpx_highbd_sad8x8x4d_sse2;
+  vpx_highbd_tm_predictor_16x16 = vpx_highbd_tm_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_tm_predictor_16x16 = vpx_highbd_tm_predictor_16x16_sse2;
+  vpx_highbd_tm_predictor_32x32 = vpx_highbd_tm_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_tm_predictor_32x32 = vpx_highbd_tm_predictor_32x32_sse2;
+  vpx_highbd_tm_predictor_4x4 = vpx_highbd_tm_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_tm_predictor_4x4 = vpx_highbd_tm_predictor_4x4_sse2;
+  vpx_highbd_tm_predictor_8x8 = vpx_highbd_tm_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_tm_predictor_8x8 = vpx_highbd_tm_predictor_8x8_sse2;
+  vpx_highbd_v_predictor_16x16 = vpx_highbd_v_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_v_predictor_16x16 = vpx_highbd_v_predictor_16x16_sse2;
+  vpx_highbd_v_predictor_32x32 = vpx_highbd_v_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_v_predictor_32x32 = vpx_highbd_v_predictor_32x32_sse2;
+  vpx_highbd_v_predictor_4x4 = vpx_highbd_v_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_v_predictor_4x4 = vpx_highbd_v_predictor_4x4_sse2;
+  vpx_highbd_v_predictor_8x8 = vpx_highbd_v_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_v_predictor_8x8 = vpx_highbd_v_predictor_8x8_sse2;
+  vpx_idct16x16_10_add = vpx_idct16x16_10_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct16x16_10_add = vpx_idct16x16_10_add_sse2;
+  vpx_idct16x16_1_add = vpx_idct16x16_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct16x16_1_add = vpx_idct16x16_1_add_sse2;
+  vpx_idct16x16_256_add = vpx_idct16x16_256_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct16x16_256_add = vpx_idct16x16_256_add_sse2;
+  vpx_idct16x16_38_add = vpx_idct16x16_38_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct16x16_38_add = vpx_idct16x16_38_add_sse2;
+  vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_sse2;
+  vpx_idct32x32_135_add = vpx_idct32x32_135_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct32x32_135_add = vpx_idct32x32_1024_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct32x32_135_add = vpx_idct32x32_135_add_ssse3;
+  vpx_idct32x32_1_add = vpx_idct32x32_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct32x32_1_add = vpx_idct32x32_1_add_sse2;
+  vpx_idct32x32_34_add = vpx_idct32x32_34_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct32x32_34_add = vpx_idct32x32_34_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct32x32_34_add = vpx_idct32x32_34_add_ssse3;
+  vpx_idct4x4_16_add = vpx_idct4x4_16_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct4x4_16_add = vpx_idct4x4_16_add_sse2;
+  vpx_idct4x4_1_add = vpx_idct4x4_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct4x4_1_add = vpx_idct4x4_1_add_sse2;
+  vpx_idct8x8_12_add = vpx_idct8x8_12_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct8x8_12_add = vpx_idct8x8_12_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct8x8_12_add = vpx_idct8x8_12_add_ssse3;
+  vpx_idct8x8_1_add = vpx_idct8x8_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct8x8_1_add = vpx_idct8x8_1_add_sse2;
+  vpx_idct8x8_64_add = vpx_idct8x8_64_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct8x8_64_add = vpx_idct8x8_64_add_sse2;
+  vpx_int_pro_col = vpx_int_pro_col_c;
+  if (flags & HAS_SSE2)
+    vpx_int_pro_col = vpx_int_pro_col_sse2;
+  vpx_int_pro_row = vpx_int_pro_row_c;
+  if (flags & HAS_SSE2)
+    vpx_int_pro_row = vpx_int_pro_row_sse2;
+  vpx_iwht4x4_16_add = vpx_iwht4x4_16_add_c;
+  if (flags & HAS_SSE2)
+    vpx_iwht4x4_16_add = vpx_iwht4x4_16_add_sse2;
+  vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_avx2;
+  vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_sse2;
+  if (flags & HAS_AVX2)
+    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_avx2;
+  vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_sse2;
+  vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_sse2;
+  vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_sse2;
+  vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_sse2;
+  vpx_lpf_vertical_16 = vpx_lpf_vertical_16_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_16 = vpx_lpf_vertical_16_sse2;
+  vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_sse2;
+  vpx_lpf_vertical_4 = vpx_lpf_vertical_4_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_4 = vpx_lpf_vertical_4_sse2;
+  vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_sse2;
+  vpx_lpf_vertical_8 = vpx_lpf_vertical_8_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_8 = vpx_lpf_vertical_8_sse2;
+  vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_sse2;
+  vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_c;
+  if (flags & HAS_SSE2)
+    vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_sse2;
+  vpx_mbpost_proc_down = vpx_mbpost_proc_down_c;
+  if (flags & HAS_SSE2)
+    vpx_mbpost_proc_down = vpx_mbpost_proc_down_sse2;
+  vpx_minmax_8x8 = vpx_minmax_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_minmax_8x8 = vpx_minmax_8x8_sse2;
+  vpx_mse16x16 = vpx_mse16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_mse16x16 = vpx_mse16x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_mse16x16 = vpx_mse16x16_avx2;
+  vpx_mse16x8 = vpx_mse16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_mse16x8 = vpx_mse16x8_sse2;
+  vpx_mse8x16 = vpx_mse8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_mse8x16 = vpx_mse8x16_sse2;
+  vpx_mse8x8 = vpx_mse8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_mse8x8 = vpx_mse8x8_sse2;
+  vpx_plane_add_noise = vpx_plane_add_noise_c;
+  if (flags & HAS_SSE2)
+    vpx_plane_add_noise = vpx_plane_add_noise_sse2;
+  vpx_post_proc_down_and_across_mb_row = vpx_post_proc_down_and_across_mb_row_c;
+  if (flags & HAS_SSE2)
+    vpx_post_proc_down_and_across_mb_row =
+        vpx_post_proc_down_and_across_mb_row_sse2;
+  vpx_quantize_b = vpx_quantize_b_c;
+  if (flags & HAS_SSE2)
+    vpx_quantize_b = vpx_quantize_b_sse2;
+  vpx_sad16x16 = vpx_sad16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x16 = vpx_sad16x16_sse2;
+  vpx_sad16x16_avg = vpx_sad16x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x16_avg = vpx_sad16x16_avg_sse2;
+  vpx_sad16x16x3 = vpx_sad16x16x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad16x16x3 = vpx_sad16x16x3_sse3;
+  if (flags & HAS_SSSE3)
+    vpx_sad16x16x3 = vpx_sad16x16x3_ssse3;
+  vpx_sad16x16x4d = vpx_sad16x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x16x4d = vpx_sad16x16x4d_sse2;
+  vpx_sad16x16x8 = vpx_sad16x16x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad16x16x8 = vpx_sad16x16x8_sse4_1;
+  vpx_sad16x32 = vpx_sad16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x32 = vpx_sad16x32_sse2;
+  vpx_sad16x32_avg = vpx_sad16x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x32_avg = vpx_sad16x32_avg_sse2;
+  vpx_sad16x32x4d = vpx_sad16x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x32x4d = vpx_sad16x32x4d_sse2;
+  vpx_sad16x8 = vpx_sad16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x8 = vpx_sad16x8_sse2;
+  vpx_sad16x8_avg = vpx_sad16x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x8_avg = vpx_sad16x8_avg_sse2;
+  vpx_sad16x8x3 = vpx_sad16x8x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad16x8x3 = vpx_sad16x8x3_sse3;
+  if (flags & HAS_SSSE3)
+    vpx_sad16x8x3 = vpx_sad16x8x3_ssse3;
+  vpx_sad16x8x4d = vpx_sad16x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x8x4d = vpx_sad16x8x4d_sse2;
+  vpx_sad16x8x8 = vpx_sad16x8x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad16x8x8 = vpx_sad16x8x8_sse4_1;
+  vpx_sad32x16 = vpx_sad32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x16 = vpx_sad32x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x16 = vpx_sad32x16_avx2;
+  vpx_sad32x16_avg = vpx_sad32x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x16_avg = vpx_sad32x16_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x16_avg = vpx_sad32x16_avg_avx2;
+  vpx_sad32x16x4d = vpx_sad32x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x16x4d = vpx_sad32x16x4d_sse2;
+  vpx_sad32x32 = vpx_sad32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x32 = vpx_sad32x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32 = vpx_sad32x32_avx2;
+  vpx_sad32x32_avg = vpx_sad32x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x32_avg = vpx_sad32x32_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32_avg = vpx_sad32x32_avg_avx2;
+  vpx_sad32x32x4d = vpx_sad32x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x32x4d = vpx_sad32x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32x4d = vpx_sad32x32x4d_avx2;
+  vpx_sad32x64 = vpx_sad32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x64 = vpx_sad32x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x64 = vpx_sad32x64_avx2;
+  vpx_sad32x64_avg = vpx_sad32x64_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x64_avg = vpx_sad32x64_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x64_avg = vpx_sad32x64_avg_avx2;
+  vpx_sad32x64x4d = vpx_sad32x64x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x64x4d = vpx_sad32x64x4d_sse2;
+  vpx_sad4x4 = vpx_sad4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x4 = vpx_sad4x4_sse2;
+  vpx_sad4x4_avg = vpx_sad4x4_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x4_avg = vpx_sad4x4_avg_sse2;
+  vpx_sad4x4x3 = vpx_sad4x4x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad4x4x3 = vpx_sad4x4x3_sse3;
+  vpx_sad4x4x4d = vpx_sad4x4x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x4x4d = vpx_sad4x4x4d_sse2;
+  vpx_sad4x4x8 = vpx_sad4x4x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad4x4x8 = vpx_sad4x4x8_sse4_1;
+  vpx_sad4x8 = vpx_sad4x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x8 = vpx_sad4x8_sse2;
+  vpx_sad4x8_avg = vpx_sad4x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x8_avg = vpx_sad4x8_avg_sse2;
+  vpx_sad4x8x4d = vpx_sad4x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x8x4d = vpx_sad4x8x4d_sse2;
+  vpx_sad64x32 = vpx_sad64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x32 = vpx_sad64x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x32 = vpx_sad64x32_avx2;
+  vpx_sad64x32_avg = vpx_sad64x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x32_avg = vpx_sad64x32_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x32_avg = vpx_sad64x32_avg_avx2;
+  vpx_sad64x32x4d = vpx_sad64x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x32x4d = vpx_sad64x32x4d_sse2;
+  vpx_sad64x64 = vpx_sad64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x64 = vpx_sad64x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64 = vpx_sad64x64_avx2;
+  vpx_sad64x64_avg = vpx_sad64x64_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x64_avg = vpx_sad64x64_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64_avg = vpx_sad64x64_avg_avx2;
+  vpx_sad64x64x4d = vpx_sad64x64x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x64x4d = vpx_sad64x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64x4d = vpx_sad64x64x4d_avx2;
+  vpx_sad8x16 = vpx_sad8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x16 = vpx_sad8x16_sse2;
+  vpx_sad8x16_avg = vpx_sad8x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x16_avg = vpx_sad8x16_avg_sse2;
+  vpx_sad8x16x3 = vpx_sad8x16x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad8x16x3 = vpx_sad8x16x3_sse3;
+  vpx_sad8x16x4d = vpx_sad8x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x16x4d = vpx_sad8x16x4d_sse2;
+  vpx_sad8x16x8 = vpx_sad8x16x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad8x16x8 = vpx_sad8x16x8_sse4_1;
+  vpx_sad8x4 = vpx_sad8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x4 = vpx_sad8x4_sse2;
+  vpx_sad8x4_avg = vpx_sad8x4_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x4_avg = vpx_sad8x4_avg_sse2;
+  vpx_sad8x4x4d = vpx_sad8x4x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x4x4d = vpx_sad8x4x4d_sse2;
+  vpx_sad8x8 = vpx_sad8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x8 = vpx_sad8x8_sse2;
+  vpx_sad8x8_avg = vpx_sad8x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x8_avg = vpx_sad8x8_avg_sse2;
+  vpx_sad8x8x3 = vpx_sad8x8x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad8x8x3 = vpx_sad8x8x3_sse3;
+  vpx_sad8x8x4d = vpx_sad8x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x8x4d = vpx_sad8x8x4d_sse2;
+  vpx_sad8x8x8 = vpx_sad8x8x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad8x8x8 = vpx_sad8x8x8_sse4_1;
+  vpx_satd = vpx_satd_c;
+  if (flags & HAS_SSE2)
+    vpx_satd = vpx_satd_sse2;
+  vpx_scaled_2d = vpx_scaled_2d_c;
+  if (flags & HAS_SSSE3)
+    vpx_scaled_2d = vpx_scaled_2d_ssse3;
+  vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_ssse3;
+  vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_ssse3;
+  vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_ssse3;
+  vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_ssse3;
+  vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_avx2;
+  vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_ssse3;
+  vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_ssse3;
+  vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_ssse3;
+  vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_ssse3;
+  vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_avx2;
+  vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_ssse3;
+  vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_ssse3;
+  vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_ssse3;
+  vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_ssse3;
+  vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_ssse3;
+  vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_ssse3;
+  vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_ssse3;
+  vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_avx2;
+  vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_ssse3;
+  vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_ssse3;
+  vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_ssse3;
+  vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_ssse3;
+  vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_avx2;
+  vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_ssse3;
+  vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_ssse3;
+  vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_ssse3;
+  vpx_subtract_block = vpx_subtract_block_c;
+  if (flags & HAS_SSE2)
+    vpx_subtract_block = vpx_subtract_block_sse2;
+  vpx_sum_squares_2d_i16 = vpx_sum_squares_2d_i16_c;
+  if (flags & HAS_SSE2)
+    vpx_sum_squares_2d_i16 = vpx_sum_squares_2d_i16_sse2;
+  vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_sse2;
+  vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_sse2;
+  vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_sse2;
+  vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_sse2;
+  vpx_v_predictor_16x16 = vpx_v_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_v_predictor_16x16 = vpx_v_predictor_16x16_sse2;
+  vpx_v_predictor_32x32 = vpx_v_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_v_predictor_32x32 = vpx_v_predictor_32x32_sse2;
+  vpx_v_predictor_4x4 = vpx_v_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_v_predictor_4x4 = vpx_v_predictor_4x4_sse2;
+  vpx_v_predictor_8x8 = vpx_v_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_v_predictor_8x8 = vpx_v_predictor_8x8_sse2;
+  vpx_variance16x16 = vpx_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_variance16x16 = vpx_variance16x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance16x16 = vpx_variance16x16_avx2;
+  vpx_variance16x32 = vpx_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_variance16x32 = vpx_variance16x32_sse2;
+  vpx_variance16x8 = vpx_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_variance16x8 = vpx_variance16x8_sse2;
+  vpx_variance32x16 = vpx_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_variance32x16 = vpx_variance32x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance32x16 = vpx_variance32x16_avx2;
+  vpx_variance32x32 = vpx_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_variance32x32 = vpx_variance32x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance32x32 = vpx_variance32x32_avx2;
+  vpx_variance32x64 = vpx_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_variance32x64 = vpx_variance32x64_sse2;
+  vpx_variance4x4 = vpx_variance4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_variance4x4 = vpx_variance4x4_sse2;
+  vpx_variance4x8 = vpx_variance4x8_c;
+  if (flags & HAS_SSE2)
+    vpx_variance4x8 = vpx_variance4x8_sse2;
+  vpx_variance64x32 = vpx_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_variance64x32 = vpx_variance64x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance64x32 = vpx_variance64x32_avx2;
+  vpx_variance64x64 = vpx_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_variance64x64 = vpx_variance64x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance64x64 = vpx_variance64x64_avx2;
+  vpx_variance8x16 = vpx_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_variance8x16 = vpx_variance8x16_sse2;
+  vpx_variance8x4 = vpx_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_variance8x4 = vpx_variance8x4_sse2;
+  vpx_variance8x8 = vpx_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_variance8x8 = vpx_variance8x8_sse2;
+  vpx_vector_var = vpx_vector_var_c;
+  if (flags & HAS_SSE2)
+    vpx_vector_var = vpx_vector_var_sse2;
 }
 #endif
 

third_party/libvpx/source/config/linux/ia32/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/ia32/vpx_scale_rtcd.h b/third_party/libvpx/source/config/linux/ia32/vpx_scale_rtcd.h
index ada0f6d..0ba352cb 100644
--- a/third_party/libvpx/source/config/linux/ia32/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/linux/ia32/vpx_scale_rtcd.h
@@ -13,55 +13,81 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/linux/mips64el/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/mips64el/vp8_rtcd.h b/third_party/libvpx/source/config/linux/mips64el/vp8_rtcd.h
index 650bd323..5af3874 100644
--- a/third_party/libvpx/source/config/linux/mips64el/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/linux/mips64el/vp8_rtcd.h
@@ -26,142 +26,312 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
 #define vp8_bilinear_predict16x16 vp8_bilinear_predict16x16_c
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict4x4 vp8_bilinear_predict4x4_c
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict8x4 vp8_bilinear_predict8x4_c
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict8x8 vp8_bilinear_predict8x8_c
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
 #define vp8_block_error vp8_block_error_c
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
 #define vp8_copy_mem16x16 vp8_copy_mem16x16_c
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
 #define vp8_copy_mem8x4 vp8_copy_mem8x4_c
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
 #define vp8_copy_mem8x8 vp8_copy_mem8x8_c
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
 #define vp8_dc_only_idct_add vp8_dc_only_idct_add_c
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
 #define vp8_denoiser_filter vp8_denoiser_filter_c
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
 #define vp8_denoiser_filter_uv vp8_denoiser_filter_uv_c
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
 #define vp8_dequant_idct_add vp8_dequant_idct_add_c
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
 #define vp8_dequant_idct_add_uv_block vp8_dequant_idct_add_uv_block_c
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
 #define vp8_dequant_idct_add_y_block vp8_dequant_idct_add_y_block_c
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
 #define vp8_dequantize_b vp8_dequantize_b_c
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
 #define vp8_diamond_search_sad vp8_diamond_search_sad_c
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
 #define vp8_fast_quantize_b vp8_fast_quantize_b_c
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp8_filter_by_weight16x16 vp8_filter_by_weight16x16_c
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight8x8 vp8_filter_by_weight8x8_c
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
 #define vp8_full_search_sad vp8_full_search_sad_c
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
 #define vp8_loop_filter_bh vp8_loop_filter_bh_c
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
 #define vp8_loop_filter_bv vp8_loop_filter_bv_c
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbh vp8_loop_filter_mbh_c
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbv vp8_loop_filter_mbv_c
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
 #define vp8_loop_filter_simple_bh vp8_loop_filter_bhs_c
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
 #define vp8_loop_filter_simple_bv vp8_loop_filter_bvs_c
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbh vp8_loop_filter_simple_horizontal_edge_c
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbv vp8_loop_filter_simple_vertical_edge_c
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
 #define vp8_mbblock_error vp8_mbblock_error_c
 
-int vp8_mbuverror_c(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
 #define vp8_mbuverror vp8_mbuverror_c
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
 #define vp8_refining_search_sad vp8_refining_search_sad_c
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
 #define vp8_regular_quantize_b vp8_regular_quantize_b_c
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
 #define vp8_short_fdct4x4 vp8_short_fdct4x4_c
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
 #define vp8_short_fdct8x4 vp8_short_fdct8x4_c
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
 #define vp8_short_idct4x4llm vp8_short_idct4x4llm_c
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4 vp8_short_inv_walsh4x4_c
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
 #define vp8_short_walsh4x4 vp8_short_walsh4x4_c
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_sixtap_predict16x16 vp8_sixtap_predict16x16_c
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict4x4 vp8_sixtap_predict4x4_c
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict8x4 vp8_sixtap_predict8x4_c
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict8x8 vp8_sixtap_predict8x8_c
 
 void vp8_rtcd(void);
@@ -169,9 +339,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/linux/mips64el/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/mips64el/vp9_rtcd.h b/third_party/libvpx/source/config/linux/mips64el/vp9_rtcd.h
index 9937e41..2579860 100644
--- a/third_party/libvpx/source/config/linux/mips64el/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/linux/mips64el/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,58 +30,148 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
 #define vp9_block_error vp9_block_error_c
 
-int64_t vp9_block_error_fp_c(const int16_t *coeff, const int16_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const int16_t* coeff,
+                             const int16_t* dqcoeff,
+                             int block_size);
 #define vp9_block_error_fp vp9_block_error_fp_c
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
 #define vp9_denoiser_filter vp9_denoiser_filter_c
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
 #define vp9_diamond_search_sad vp9_diamond_search_sad_c
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
 #define vp9_fdct8x8_quant vp9_fdct8x8_quant_c
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
 #define vp9_fht16x16 vp9_fht16x16_c
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht4x4 vp9_fht4x4_c
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht8x8 vp9_fht8x8_c
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp9_filter_by_weight16x16 vp9_filter_by_weight16x16_c
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp9_filter_by_weight8x8 vp9_filter_by_weight8x8_c
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_fwht4x4 vp9_fwht4x4_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
 #define vp9_iht16x16_256_add vp9_iht16x16_256_add_c
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
 #define vp9_iht4x4_16_add vp9_iht4x4_16_add_c
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
 #define vp9_iht8x8_64_add vp9_iht8x8_64_add_c
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
 #define vp9_quantize_fp vp9_quantize_fp_c
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vp9_quantize_fp_32x32 vp9_quantize_fp_32x32_c
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
 #define vp9_scale_and_extend_frame vp9_scale_and_extend_frame_c
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
 #define vp9_temporal_filter_apply vp9_temporal_filter_apply_c
 
 void vp9_rtcd(void);
@@ -89,9 +179,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/linux/mips64el/vpx_config.h

diff --git a/third_party/libvpx/source/config/linux/mips64el/vpx_config.h b/third_party/libvpx/source/config/linux/mips64el/vpx_config.h
index 6d0fb9c8..8bc4861 100644
--- a/third_party/libvpx/source/config/linux/mips64el/vpx_config.h
+++ b/third_party/libvpx/source/config/linux/mips64el/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 0
 #define HAVE_AVX2 0
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/linux/mips64el/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/mips64el/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/linux/mips64el/vpx_dsp_rtcd.h
index ad1d5d25..9fae69e 100644
--- a/third_party/libvpx/source/config/linux/mips64el/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/linux/mips64el/vpx_dsp_rtcd.h
@@ -14,669 +14,1530 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
 #define vpx_avg_4x4 vpx_avg_4x4_c
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
 #define vpx_avg_8x8 vpx_avg_8x8_c
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
 #define vpx_comp_avg_pred vpx_comp_avg_pred_c
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_convolve8 vpx_convolve8_c
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_convolve8_avg vpx_convolve8_avg_c
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
 #define vpx_convolve8_avg_horiz vpx_convolve8_avg_horiz_c
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
 #define vpx_convolve8_avg_vert vpx_convolve8_avg_vert_c
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_convolve8_horiz vpx_convolve8_horiz_c
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
 #define vpx_convolve8_vert vpx_convolve8_vert_c
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_convolve_avg vpx_convolve_avg_c
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_convolve_copy vpx_convolve_copy_c
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_c
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_c
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_c
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_c
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_16x16 vpx_d153_predictor_16x16_c
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_32x32 vpx_d153_predictor_32x32_c
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_4x4 vpx_d153_predictor_4x4_c
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_8x8 vpx_d153_predictor_8x8_c
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_16x16 vpx_d207_predictor_16x16_c
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_32x32 vpx_d207_predictor_32x32_c
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_4x4 vpx_d207_predictor_4x4_c
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_8x8 vpx_d207_predictor_8x8_c
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d45_predictor_16x16 vpx_d45_predictor_16x16_c
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d45_predictor_32x32 vpx_d45_predictor_32x32_c
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d45_predictor_4x4 vpx_d45_predictor_4x4_c
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d45_predictor_8x8 vpx_d45_predictor_8x8_c
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_16x16 vpx_d63_predictor_16x16_c
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_32x32 vpx_d63_predictor_32x32_c
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_4x4 vpx_d63_predictor_4x4_c
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_8x8 vpx_d63_predictor_8x8_c
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_128_predictor_16x16 vpx_dc_128_predictor_16x16_c
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_128_predictor_32x32 vpx_dc_128_predictor_32x32_c
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_128_predictor_4x4 vpx_dc_128_predictor_4x4_c
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_128_predictor_8x8 vpx_dc_128_predictor_8x8_c
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_left_predictor_16x16 vpx_dc_left_predictor_16x16_c
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_left_predictor_32x32 vpx_dc_left_predictor_32x32_c
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_left_predictor_4x4 vpx_dc_left_predictor_4x4_c
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_left_predictor_8x8 vpx_dc_left_predictor_8x8_c
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_dc_predictor_16x16 vpx_dc_predictor_16x16_c
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_dc_predictor_32x32 vpx_dc_predictor_32x32_c
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_dc_predictor_4x4 vpx_dc_predictor_4x4_c
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_dc_predictor_8x8 vpx_dc_predictor_8x8_c
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_top_predictor_16x16 vpx_dc_top_predictor_16x16_c
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_top_predictor_32x32 vpx_dc_top_predictor_32x32_c
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_top_predictor_4x4 vpx_dc_top_predictor_4x4_c
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_top_predictor_8x8 vpx_dc_top_predictor_8x8_c
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16 vpx_fdct16x16_c
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16_1 vpx_fdct16x16_1_c
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32 vpx_fdct32x32_c
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_1 vpx_fdct32x32_1_c
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_rd vpx_fdct32x32_rd_c
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4 vpx_fdct4x4_c
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4_1 vpx_fdct4x4_1_c
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8 vpx_fdct8x8_c
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8_1 vpx_fdct8x8_1_c
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
 #define vpx_get16x16var vpx_get16x16var_c
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_c
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
 #define vpx_get8x8var vpx_get8x8var_c
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
 #define vpx_get_mb_ss vpx_get_mb_ss_c
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_h_predictor_16x16 vpx_h_predictor_16x16_c
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_h_predictor_32x32 vpx_h_predictor_32x32_c
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_h_predictor_4x4 vpx_h_predictor_4x4_c
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_h_predictor_8x8 vpx_h_predictor_8x8_c
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          int16_t* coeff);
 #define vpx_hadamard_16x16 vpx_hadamard_16x16_c
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        int16_t* coeff);
 #define vpx_hadamard_8x8 vpx_hadamard_8x8_c
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_10_add vpx_idct16x16_10_add_c
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_1_add vpx_idct16x16_1_add_c
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct16x16_256_add vpx_idct16x16_256_add_c
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_38_add vpx_idct16x16_38_add_c
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct32x32_1024_add vpx_idct32x32_1024_add_c
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct32x32_135_add vpx_idct32x32_135_add_c
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct32x32_1_add vpx_idct32x32_1_add_c
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct32x32_34_add vpx_idct32x32_34_add_c
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_16_add vpx_idct4x4_16_add_c
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_1_add vpx_idct4x4_1_add_c
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_12_add vpx_idct8x8_12_add_c
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_1_add vpx_idct8x8_1_add_c
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_64_add vpx_idct8x8_64_add_c
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
 #define vpx_int_pro_col vpx_int_pro_col_c
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
 #define vpx_int_pro_row vpx_int_pro_row_c
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_16_add vpx_iwht4x4_16_add_c
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_horizontal_16 vpx_lpf_horizontal_16_c
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
 #define vpx_lpf_horizontal_16_dual vpx_lpf_horizontal_16_dual_c
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
 #define vpx_lpf_horizontal_4 vpx_lpf_horizontal_4_c
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
 #define vpx_lpf_horizontal_4_dual vpx_lpf_horizontal_4_dual_c
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
 #define vpx_lpf_horizontal_8 vpx_lpf_horizontal_8_c
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
 #define vpx_lpf_horizontal_8_dual vpx_lpf_horizontal_8_dual_c
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
 #define vpx_lpf_vertical_16 vpx_lpf_vertical_16_c
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
 #define vpx_lpf_vertical_16_dual vpx_lpf_vertical_16_dual_c
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
 #define vpx_lpf_vertical_4 vpx_lpf_vertical_4_c
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
 #define vpx_lpf_vertical_4_dual vpx_lpf_vertical_4_dual_c
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
 #define vpx_lpf_vertical_8 vpx_lpf_vertical_8_c
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
 #define vpx_lpf_vertical_8_dual vpx_lpf_vertical_8_dual_c
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
 #define vpx_mbpost_proc_across_ip vpx_mbpost_proc_across_ip_c
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
 #define vpx_mbpost_proc_down vpx_mbpost_proc_down_c
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
 #define vpx_minmax_8x8 vpx_minmax_8x8_c
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
 #define vpx_mse16x16 vpx_mse16x16_c
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse16x8 vpx_mse16x8_c
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse8x16 vpx_mse8x16_c
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
 #define vpx_mse8x8 vpx_mse8x8_c
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
 #define vpx_plane_add_noise vpx_plane_add_noise_c
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-#define vpx_post_proc_down_and_across_mb_row vpx_post_proc_down_and_across_mb_row_c
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+#define vpx_post_proc_down_and_across_mb_row \
+  vpx_post_proc_down_and_across_mb_row_c
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
 #define vpx_quantize_b vpx_quantize_b_c
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vpx_quantize_b_32x32 vpx_quantize_b_32x32_c
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad16x16 vpx_sad16x16_c
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad16x16_avg vpx_sad16x16_avg_c
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x3 vpx_sad16x16x3_c
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad16x16x4d vpx_sad16x16x4d_c
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x8 vpx_sad16x16x8_c
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad16x32 vpx_sad16x32_c
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad16x32_avg vpx_sad16x32_avg_c
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad16x32x4d vpx_sad16x32x4d_c
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
 #define vpx_sad16x8 vpx_sad16x8_c
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
 #define vpx_sad16x8_avg vpx_sad16x8_avg_c
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x3 vpx_sad16x8x3_c
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x8x4d vpx_sad16x8x4d_c
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x8 vpx_sad16x8x8_c
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x16 vpx_sad32x16_c
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x16_avg vpx_sad32x16_avg_c
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x16x4d vpx_sad32x16x4d_c
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x32 vpx_sad32x32_c
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x32_avg vpx_sad32x32_avg_c
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x32x4d vpx_sad32x32x4d_c
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x64 vpx_sad32x64_c
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x64_avg vpx_sad32x64_avg_c
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x64x4d vpx_sad32x64x4d_c
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad4x4 vpx_sad4x4_c
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad4x4_avg vpx_sad4x4_avg_c
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x3 vpx_sad4x4x3_c
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad4x4x4d vpx_sad4x4x4d_c
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x8 vpx_sad4x4x8_c
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad4x8 vpx_sad4x8_c
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad4x8_avg vpx_sad4x8_avg_c
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad4x8x4d vpx_sad4x8x4d_c
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad64x32 vpx_sad64x32_c
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad64x32_avg vpx_sad64x32_avg_c
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad64x32x4d vpx_sad64x32x4d_c
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad64x64 vpx_sad64x64_c
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad64x64_avg vpx_sad64x64_avg_c
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad64x64x4d vpx_sad64x64x4d_c
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
 #define vpx_sad8x16 vpx_sad8x16_c
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
 #define vpx_sad8x16_avg vpx_sad8x16_avg_c
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x3 vpx_sad8x16x3_c
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad8x16x4d vpx_sad8x16x4d_c
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x8 vpx_sad8x16x8_c
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad8x4 vpx_sad8x4_c
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad8x4_avg vpx_sad8x4_avg_c
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x4x4d vpx_sad8x4x4d_c
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad8x8 vpx_sad8x8_c
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad8x8_avg vpx_sad8x8_avg_c
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x3 vpx_sad8x8x3_c
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x8x4d vpx_sad8x8x4d_c
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x8 vpx_sad8x8x8_c
 
-int vpx_satd_c(const int16_t *coeff, int length);
+int vpx_satd_c(const int16_t* coeff, int length);
 #define vpx_satd vpx_satd_c
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_scaled_2d vpx_scaled_2d_c
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x16 vpx_sub_pixel_avg_variance16x16_c
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x32 vpx_sub_pixel_avg_variance16x32_c
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x8 vpx_sub_pixel_avg_variance16x8_c
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x16 vpx_sub_pixel_avg_variance32x16_c
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x32 vpx_sub_pixel_avg_variance32x32_c
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x64 vpx_sub_pixel_avg_variance32x64_c
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x4 vpx_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x8 vpx_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x32 vpx_sub_pixel_avg_variance64x32_c
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x64 vpx_sub_pixel_avg_variance64x64_c
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x16 vpx_sub_pixel_avg_variance8x16_c
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x4 vpx_sub_pixel_avg_variance8x4_c
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x8 vpx_sub_pixel_avg_variance8x8_c
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance16x16 vpx_sub_pixel_variance16x16_c
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance16x32 vpx_sub_pixel_variance16x32_c
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
 #define vpx_sub_pixel_variance16x8 vpx_sub_pixel_variance16x8_c
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x16 vpx_sub_pixel_variance32x16_c
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x32 vpx_sub_pixel_variance32x32_c
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x64 vpx_sub_pixel_variance32x64_c
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance4x4 vpx_sub_pixel_variance4x4_c
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance4x8 vpx_sub_pixel_variance4x8_c
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance64x32 vpx_sub_pixel_variance64x32_c
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance64x64 vpx_sub_pixel_variance64x64_c
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
 #define vpx_sub_pixel_variance8x16 vpx_sub_pixel_variance8x16_c
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance8x4 vpx_sub_pixel_variance8x4_c
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance8x8 vpx_sub_pixel_variance8x8_c
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
 #define vpx_subtract_block vpx_subtract_block_c
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
 #define vpx_sum_squares_2d_i16 vpx_sum_squares_2d_i16_c
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_tm_predictor_16x16 vpx_tm_predictor_16x16_c
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_tm_predictor_32x32 vpx_tm_predictor_32x32_c
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_tm_predictor_4x4 vpx_tm_predictor_4x4_c
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_tm_predictor_8x8 vpx_tm_predictor_8x8_c
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_v_predictor_16x16 vpx_v_predictor_16x16_c
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_v_predictor_32x32 vpx_v_predictor_32x32_c
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_v_predictor_4x4 vpx_v_predictor_4x4_c
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_v_predictor_8x8 vpx_v_predictor_8x8_c
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance16x16 vpx_variance16x16_c
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance16x32 vpx_variance16x32_c
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
 #define vpx_variance16x8 vpx_variance16x8_c
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x16 vpx_variance32x16_c
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x32 vpx_variance32x32_c
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x64 vpx_variance32x64_c
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance4x4 vpx_variance4x4_c
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance4x8 vpx_variance4x8_c
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance64x32 vpx_variance64x32_c
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance64x64 vpx_variance64x64_c
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
 #define vpx_variance8x16 vpx_variance8x16_c
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance8x4 vpx_variance8x4_c
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance8x8 vpx_variance8x8_c
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
 #define vpx_vector_var vpx_vector_var_c
 
 void vpx_dsp_rtcd(void);
@@ -684,9 +1545,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/linux/mips64el/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/mips64el/vpx_scale_rtcd.h b/third_party/libvpx/source/config/linux/mips64el/vpx_scale_rtcd.h
index 0098208..6686511 100644
--- a/third_party/libvpx/source/config/linux/mips64el/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/linux/mips64el/vpx_scale_rtcd.h
@@ -13,43 +13,71 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
@@ -57,9 +85,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/linux/mipsel/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/mipsel/vp8_rtcd.h b/third_party/libvpx/source/config/linux/mipsel/vp8_rtcd.h
index 650bd323..5af3874 100644
--- a/third_party/libvpx/source/config/linux/mipsel/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/linux/mipsel/vp8_rtcd.h
@@ -26,142 +26,312 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
 #define vp8_bilinear_predict16x16 vp8_bilinear_predict16x16_c
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict4x4 vp8_bilinear_predict4x4_c
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict8x4 vp8_bilinear_predict8x4_c
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict8x8 vp8_bilinear_predict8x8_c
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
 #define vp8_block_error vp8_block_error_c
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
 #define vp8_copy_mem16x16 vp8_copy_mem16x16_c
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
 #define vp8_copy_mem8x4 vp8_copy_mem8x4_c
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
 #define vp8_copy_mem8x8 vp8_copy_mem8x8_c
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
 #define vp8_dc_only_idct_add vp8_dc_only_idct_add_c
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
 #define vp8_denoiser_filter vp8_denoiser_filter_c
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
 #define vp8_denoiser_filter_uv vp8_denoiser_filter_uv_c
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
 #define vp8_dequant_idct_add vp8_dequant_idct_add_c
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
 #define vp8_dequant_idct_add_uv_block vp8_dequant_idct_add_uv_block_c
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
 #define vp8_dequant_idct_add_y_block vp8_dequant_idct_add_y_block_c
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
 #define vp8_dequantize_b vp8_dequantize_b_c
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
 #define vp8_diamond_search_sad vp8_diamond_search_sad_c
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
 #define vp8_fast_quantize_b vp8_fast_quantize_b_c
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp8_filter_by_weight16x16 vp8_filter_by_weight16x16_c
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight8x8 vp8_filter_by_weight8x8_c
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
 #define vp8_full_search_sad vp8_full_search_sad_c
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
 #define vp8_loop_filter_bh vp8_loop_filter_bh_c
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
 #define vp8_loop_filter_bv vp8_loop_filter_bv_c
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbh vp8_loop_filter_mbh_c
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbv vp8_loop_filter_mbv_c
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
 #define vp8_loop_filter_simple_bh vp8_loop_filter_bhs_c
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
 #define vp8_loop_filter_simple_bv vp8_loop_filter_bvs_c
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbh vp8_loop_filter_simple_horizontal_edge_c
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbv vp8_loop_filter_simple_vertical_edge_c
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
 #define vp8_mbblock_error vp8_mbblock_error_c
 
-int vp8_mbuverror_c(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
 #define vp8_mbuverror vp8_mbuverror_c
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
 #define vp8_refining_search_sad vp8_refining_search_sad_c
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
 #define vp8_regular_quantize_b vp8_regular_quantize_b_c
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
 #define vp8_short_fdct4x4 vp8_short_fdct4x4_c
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
 #define vp8_short_fdct8x4 vp8_short_fdct8x4_c
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
 #define vp8_short_idct4x4llm vp8_short_idct4x4llm_c
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4 vp8_short_inv_walsh4x4_c
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
 #define vp8_short_walsh4x4 vp8_short_walsh4x4_c
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_sixtap_predict16x16 vp8_sixtap_predict16x16_c
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict4x4 vp8_sixtap_predict4x4_c
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict8x4 vp8_sixtap_predict8x4_c
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict8x8 vp8_sixtap_predict8x8_c
 
 void vp8_rtcd(void);
@@ -169,9 +339,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/linux/mipsel/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/mipsel/vp9_rtcd.h b/third_party/libvpx/source/config/linux/mipsel/vp9_rtcd.h
index 9937e41..2579860 100644
--- a/third_party/libvpx/source/config/linux/mipsel/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/linux/mipsel/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,58 +30,148 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
 #define vp9_block_error vp9_block_error_c
 
-int64_t vp9_block_error_fp_c(const int16_t *coeff, const int16_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const int16_t* coeff,
+                             const int16_t* dqcoeff,
+                             int block_size);
 #define vp9_block_error_fp vp9_block_error_fp_c
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
 #define vp9_denoiser_filter vp9_denoiser_filter_c
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
 #define vp9_diamond_search_sad vp9_diamond_search_sad_c
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
 #define vp9_fdct8x8_quant vp9_fdct8x8_quant_c
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
 #define vp9_fht16x16 vp9_fht16x16_c
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht4x4 vp9_fht4x4_c
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht8x8 vp9_fht8x8_c
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp9_filter_by_weight16x16 vp9_filter_by_weight16x16_c
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp9_filter_by_weight8x8 vp9_filter_by_weight8x8_c
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_fwht4x4 vp9_fwht4x4_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
 #define vp9_iht16x16_256_add vp9_iht16x16_256_add_c
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
 #define vp9_iht4x4_16_add vp9_iht4x4_16_add_c
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
 #define vp9_iht8x8_64_add vp9_iht8x8_64_add_c
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
 #define vp9_quantize_fp vp9_quantize_fp_c
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vp9_quantize_fp_32x32 vp9_quantize_fp_32x32_c
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
 #define vp9_scale_and_extend_frame vp9_scale_and_extend_frame_c
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
 #define vp9_temporal_filter_apply vp9_temporal_filter_apply_c
 
 void vp9_rtcd(void);
@@ -89,9 +179,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/linux/mipsel/vpx_config.h

diff --git a/third_party/libvpx/source/config/linux/mipsel/vpx_config.h b/third_party/libvpx/source/config/linux/mipsel/vpx_config.h
index 1054bcd9..64be8cd4 100644
--- a/third_party/libvpx/source/config/linux/mipsel/vpx_config.h
+++ b/third_party/libvpx/source/config/linux/mipsel/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 0
 #define HAVE_AVX2 0
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/linux/mipsel/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/mipsel/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/linux/mipsel/vpx_dsp_rtcd.h
index ad1d5d25..9fae69e 100644
--- a/third_party/libvpx/source/config/linux/mipsel/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/linux/mipsel/vpx_dsp_rtcd.h
@@ -14,669 +14,1530 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
 #define vpx_avg_4x4 vpx_avg_4x4_c
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
 #define vpx_avg_8x8 vpx_avg_8x8_c
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
 #define vpx_comp_avg_pred vpx_comp_avg_pred_c
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_convolve8 vpx_convolve8_c
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_convolve8_avg vpx_convolve8_avg_c
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
 #define vpx_convolve8_avg_horiz vpx_convolve8_avg_horiz_c
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
 #define vpx_convolve8_avg_vert vpx_convolve8_avg_vert_c
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_convolve8_horiz vpx_convolve8_horiz_c
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
 #define vpx_convolve8_vert vpx_convolve8_vert_c
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_convolve_avg vpx_convolve_avg_c
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_convolve_copy vpx_convolve_copy_c
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_c
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_c
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_c
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_c
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_16x16 vpx_d153_predictor_16x16_c
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_32x32 vpx_d153_predictor_32x32_c
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_4x4 vpx_d153_predictor_4x4_c
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_8x8 vpx_d153_predictor_8x8_c
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_16x16 vpx_d207_predictor_16x16_c
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_32x32 vpx_d207_predictor_32x32_c
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_4x4 vpx_d207_predictor_4x4_c
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_8x8 vpx_d207_predictor_8x8_c
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d45_predictor_16x16 vpx_d45_predictor_16x16_c
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d45_predictor_32x32 vpx_d45_predictor_32x32_c
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d45_predictor_4x4 vpx_d45_predictor_4x4_c
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d45_predictor_8x8 vpx_d45_predictor_8x8_c
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_16x16 vpx_d63_predictor_16x16_c
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_32x32 vpx_d63_predictor_32x32_c
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_4x4 vpx_d63_predictor_4x4_c
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_8x8 vpx_d63_predictor_8x8_c
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_128_predictor_16x16 vpx_dc_128_predictor_16x16_c
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_128_predictor_32x32 vpx_dc_128_predictor_32x32_c
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_128_predictor_4x4 vpx_dc_128_predictor_4x4_c
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_128_predictor_8x8 vpx_dc_128_predictor_8x8_c
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_left_predictor_16x16 vpx_dc_left_predictor_16x16_c
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_left_predictor_32x32 vpx_dc_left_predictor_32x32_c
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_left_predictor_4x4 vpx_dc_left_predictor_4x4_c
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_left_predictor_8x8 vpx_dc_left_predictor_8x8_c
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_dc_predictor_16x16 vpx_dc_predictor_16x16_c
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_dc_predictor_32x32 vpx_dc_predictor_32x32_c
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_dc_predictor_4x4 vpx_dc_predictor_4x4_c
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_dc_predictor_8x8 vpx_dc_predictor_8x8_c
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_top_predictor_16x16 vpx_dc_top_predictor_16x16_c
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_top_predictor_32x32 vpx_dc_top_predictor_32x32_c
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_top_predictor_4x4 vpx_dc_top_predictor_4x4_c
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_top_predictor_8x8 vpx_dc_top_predictor_8x8_c
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16 vpx_fdct16x16_c
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16_1 vpx_fdct16x16_1_c
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32 vpx_fdct32x32_c
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_1 vpx_fdct32x32_1_c
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_rd vpx_fdct32x32_rd_c
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4 vpx_fdct4x4_c
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4_1 vpx_fdct4x4_1_c
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8 vpx_fdct8x8_c
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8_1 vpx_fdct8x8_1_c
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
 #define vpx_get16x16var vpx_get16x16var_c
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_c
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
 #define vpx_get8x8var vpx_get8x8var_c
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
 #define vpx_get_mb_ss vpx_get_mb_ss_c
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_h_predictor_16x16 vpx_h_predictor_16x16_c
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_h_predictor_32x32 vpx_h_predictor_32x32_c
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_h_predictor_4x4 vpx_h_predictor_4x4_c
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_h_predictor_8x8 vpx_h_predictor_8x8_c
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          int16_t* coeff);
 #define vpx_hadamard_16x16 vpx_hadamard_16x16_c
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, int16_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        int16_t* coeff);
 #define vpx_hadamard_8x8 vpx_hadamard_8x8_c
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_10_add vpx_idct16x16_10_add_c
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_1_add vpx_idct16x16_1_add_c
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct16x16_256_add vpx_idct16x16_256_add_c
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_38_add vpx_idct16x16_38_add_c
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct32x32_1024_add vpx_idct32x32_1024_add_c
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct32x32_135_add vpx_idct32x32_135_add_c
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct32x32_1_add vpx_idct32x32_1_add_c
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct32x32_34_add vpx_idct32x32_34_add_c
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_16_add vpx_idct4x4_16_add_c
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_1_add vpx_idct4x4_1_add_c
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_12_add vpx_idct8x8_12_add_c
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_1_add vpx_idct8x8_1_add_c
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_64_add vpx_idct8x8_64_add_c
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
 #define vpx_int_pro_col vpx_int_pro_col_c
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
 #define vpx_int_pro_row vpx_int_pro_row_c
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_16_add vpx_iwht4x4_16_add_c
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_horizontal_16 vpx_lpf_horizontal_16_c
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
 #define vpx_lpf_horizontal_16_dual vpx_lpf_horizontal_16_dual_c
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
 #define vpx_lpf_horizontal_4 vpx_lpf_horizontal_4_c
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
 #define vpx_lpf_horizontal_4_dual vpx_lpf_horizontal_4_dual_c
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
 #define vpx_lpf_horizontal_8 vpx_lpf_horizontal_8_c
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
 #define vpx_lpf_horizontal_8_dual vpx_lpf_horizontal_8_dual_c
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
 #define vpx_lpf_vertical_16 vpx_lpf_vertical_16_c
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
 #define vpx_lpf_vertical_16_dual vpx_lpf_vertical_16_dual_c
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
 #define vpx_lpf_vertical_4 vpx_lpf_vertical_4_c
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
 #define vpx_lpf_vertical_4_dual vpx_lpf_vertical_4_dual_c
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
 #define vpx_lpf_vertical_8 vpx_lpf_vertical_8_c
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
 #define vpx_lpf_vertical_8_dual vpx_lpf_vertical_8_dual_c
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
 #define vpx_mbpost_proc_across_ip vpx_mbpost_proc_across_ip_c
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
 #define vpx_mbpost_proc_down vpx_mbpost_proc_down_c
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
 #define vpx_minmax_8x8 vpx_minmax_8x8_c
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
 #define vpx_mse16x16 vpx_mse16x16_c
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse16x8 vpx_mse16x8_c
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse8x16 vpx_mse8x16_c
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
 #define vpx_mse8x8 vpx_mse8x8_c
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
 #define vpx_plane_add_noise vpx_plane_add_noise_c
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-#define vpx_post_proc_down_and_across_mb_row vpx_post_proc_down_and_across_mb_row_c
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+#define vpx_post_proc_down_and_across_mb_row \
+  vpx_post_proc_down_and_across_mb_row_c
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
 #define vpx_quantize_b vpx_quantize_b_c
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vpx_quantize_b_32x32 vpx_quantize_b_32x32_c
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad16x16 vpx_sad16x16_c
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad16x16_avg vpx_sad16x16_avg_c
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x3 vpx_sad16x16x3_c
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad16x16x4d vpx_sad16x16x4d_c
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x8 vpx_sad16x16x8_c
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad16x32 vpx_sad16x32_c
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad16x32_avg vpx_sad16x32_avg_c
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad16x32x4d vpx_sad16x32x4d_c
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
 #define vpx_sad16x8 vpx_sad16x8_c
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
 #define vpx_sad16x8_avg vpx_sad16x8_avg_c
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x3 vpx_sad16x8x3_c
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x8x4d vpx_sad16x8x4d_c
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x8 vpx_sad16x8x8_c
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x16 vpx_sad32x16_c
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x16_avg vpx_sad32x16_avg_c
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x16x4d vpx_sad32x16x4d_c
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x32 vpx_sad32x32_c
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x32_avg vpx_sad32x32_avg_c
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x32x4d vpx_sad32x32x4d_c
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x64 vpx_sad32x64_c
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x64_avg vpx_sad32x64_avg_c
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x64x4d vpx_sad32x64x4d_c
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad4x4 vpx_sad4x4_c
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad4x4_avg vpx_sad4x4_avg_c
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x3 vpx_sad4x4x3_c
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad4x4x4d vpx_sad4x4x4d_c
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x8 vpx_sad4x4x8_c
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad4x8 vpx_sad4x8_c
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad4x8_avg vpx_sad4x8_avg_c
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad4x8x4d vpx_sad4x8x4d_c
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad64x32 vpx_sad64x32_c
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad64x32_avg vpx_sad64x32_avg_c
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad64x32x4d vpx_sad64x32x4d_c
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad64x64 vpx_sad64x64_c
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad64x64_avg vpx_sad64x64_avg_c
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad64x64x4d vpx_sad64x64x4d_c
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
 #define vpx_sad8x16 vpx_sad8x16_c
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
 #define vpx_sad8x16_avg vpx_sad8x16_avg_c
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x3 vpx_sad8x16x3_c
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad8x16x4d vpx_sad8x16x4d_c
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x8 vpx_sad8x16x8_c
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad8x4 vpx_sad8x4_c
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad8x4_avg vpx_sad8x4_avg_c
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x4x4d vpx_sad8x4x4d_c
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad8x8 vpx_sad8x8_c
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad8x8_avg vpx_sad8x8_avg_c
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x3 vpx_sad8x8x3_c
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x8x4d vpx_sad8x8x4d_c
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x8 vpx_sad8x8x8_c
 
-int vpx_satd_c(const int16_t *coeff, int length);
+int vpx_satd_c(const int16_t* coeff, int length);
 #define vpx_satd vpx_satd_c
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_scaled_2d vpx_scaled_2d_c
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x16 vpx_sub_pixel_avg_variance16x16_c
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x32 vpx_sub_pixel_avg_variance16x32_c
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x8 vpx_sub_pixel_avg_variance16x8_c
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x16 vpx_sub_pixel_avg_variance32x16_c
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x32 vpx_sub_pixel_avg_variance32x32_c
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x64 vpx_sub_pixel_avg_variance32x64_c
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x4 vpx_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x8 vpx_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x32 vpx_sub_pixel_avg_variance64x32_c
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x64 vpx_sub_pixel_avg_variance64x64_c
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x16 vpx_sub_pixel_avg_variance8x16_c
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x4 vpx_sub_pixel_avg_variance8x4_c
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x8 vpx_sub_pixel_avg_variance8x8_c
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance16x16 vpx_sub_pixel_variance16x16_c
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance16x32 vpx_sub_pixel_variance16x32_c
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
 #define vpx_sub_pixel_variance16x8 vpx_sub_pixel_variance16x8_c
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x16 vpx_sub_pixel_variance32x16_c
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x32 vpx_sub_pixel_variance32x32_c
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x64 vpx_sub_pixel_variance32x64_c
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance4x4 vpx_sub_pixel_variance4x4_c
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance4x8 vpx_sub_pixel_variance4x8_c
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance64x32 vpx_sub_pixel_variance64x32_c
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance64x64 vpx_sub_pixel_variance64x64_c
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
 #define vpx_sub_pixel_variance8x16 vpx_sub_pixel_variance8x16_c
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance8x4 vpx_sub_pixel_variance8x4_c
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance8x8 vpx_sub_pixel_variance8x8_c
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
 #define vpx_subtract_block vpx_subtract_block_c
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
 #define vpx_sum_squares_2d_i16 vpx_sum_squares_2d_i16_c
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_tm_predictor_16x16 vpx_tm_predictor_16x16_c
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_tm_predictor_32x32 vpx_tm_predictor_32x32_c
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_tm_predictor_4x4 vpx_tm_predictor_4x4_c
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_tm_predictor_8x8 vpx_tm_predictor_8x8_c
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_v_predictor_16x16 vpx_v_predictor_16x16_c
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_v_predictor_32x32 vpx_v_predictor_32x32_c
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_v_predictor_4x4 vpx_v_predictor_4x4_c
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_v_predictor_8x8 vpx_v_predictor_8x8_c
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance16x16 vpx_variance16x16_c
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance16x32 vpx_variance16x32_c
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
 #define vpx_variance16x8 vpx_variance16x8_c
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x16 vpx_variance32x16_c
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x32 vpx_variance32x32_c
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x64 vpx_variance32x64_c
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance4x4 vpx_variance4x4_c
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance4x8 vpx_variance4x8_c
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance64x32 vpx_variance64x32_c
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance64x64 vpx_variance64x64_c
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
 #define vpx_variance8x16 vpx_variance8x16_c
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance8x4 vpx_variance8x4_c
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance8x8 vpx_variance8x8_c
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
 #define vpx_vector_var vpx_vector_var_c
 
 void vpx_dsp_rtcd(void);
@@ -684,9 +1545,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/linux/mipsel/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/mipsel/vpx_scale_rtcd.h b/third_party/libvpx/source/config/linux/mipsel/vpx_scale_rtcd.h
index 0098208..6686511 100644
--- a/third_party/libvpx/source/config/linux/mipsel/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/linux/mipsel/vpx_scale_rtcd.h
@@ -13,43 +13,71 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
@@ -57,9 +85,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/linux/x64/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/x64/vp8_rtcd.h b/third_party/libvpx/source/config/linux/x64/vp8_rtcd.h
index 8dcc9eb..baafe8be 100644
--- a/third_party/libvpx/source/config/linux/x64/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/linux/x64/vp8_rtcd.h
@@ -26,230 +26,647 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict16x16)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+void vp8_bilinear_predict16x16_sse2(unsigned char* src,
+                                    int src_pitch,
+                                    int xofst,
+                                    int yofst,
+                                    unsigned char* dst,
+                                    int dst_pitch);
+void vp8_bilinear_predict16x16_ssse3(unsigned char* src,
+                                     int src_pitch,
+                                     int xofst,
+                                     int yofst,
+                                     unsigned char* dst,
+                                     int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict16x16)(unsigned char* src,
+                                              int src_pitch,
+                                              int xofst,
+                                              int yofst,
+                                              unsigned char* dst,
+                                              int dst_pitch);
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict4x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict4x4_mmx(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
 #define vp8_bilinear_predict4x4 vp8_bilinear_predict4x4_mmx
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x4_mmx(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
 #define vp8_bilinear_predict8x4 vp8_bilinear_predict8x4_mmx
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict8x8)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x8_sse2(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+void vp8_bilinear_predict8x8_ssse3(unsigned char* src,
+                                   int src_pitch,
+                                   int xofst,
+                                   int yofst,
+                                   unsigned char* dst,
+                                   int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict8x8)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
-int vp8_block_error_sse2(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
+int vp8_block_error_sse2(short* coeff, short* dqcoeff);
 #define vp8_block_error vp8_block_error_sse2
 
-void vp8_copy32xn_c(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-void vp8_copy32xn_sse2(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-void vp8_copy32xn_sse3(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-RTCD_EXTERN void (*vp8_copy32xn)(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
+void vp8_copy32xn_c(const unsigned char* src_ptr,
+                    int source_stride,
+                    unsigned char* dst_ptr,
+                    int dst_stride,
+                    int n);
+void vp8_copy32xn_sse2(const unsigned char* src_ptr,
+                       int source_stride,
+                       unsigned char* dst_ptr,
+                       int dst_stride,
+                       int n);
+void vp8_copy32xn_sse3(const unsigned char* src_ptr,
+                       int source_stride,
+                       unsigned char* dst_ptr,
+                       int dst_stride,
+                       int n);
+RTCD_EXTERN void (*vp8_copy32xn)(const unsigned char* src_ptr,
+                                 int source_stride,
+                                 unsigned char* dst_ptr,
+                                 int dst_stride,
+                                 int n);
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem16x16_sse2(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+void vp8_copy_mem16x16_sse2(unsigned char* src,
+                            int src_pitch,
+                            unsigned char* dst,
+                            int dst_pitch);
 #define vp8_copy_mem16x16 vp8_copy_mem16x16_sse2
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x4_mmx(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x4_mmx(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
 #define vp8_copy_mem8x4 vp8_copy_mem8x4_mmx
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x8_mmx(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x8_mmx(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
 #define vp8_copy_mem8x8 vp8_copy_mem8x8_mmx
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-void vp8_dc_only_idct_add_mmx(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_dc_only_idct_add_mmx(short input,
+                              unsigned char* pred,
+                              int pred_stride,
+                              unsigned char* dst,
+                              int dst_stride);
 #define vp8_dc_only_idct_add vp8_dc_only_idct_add_mmx
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_sse2(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
+int vp8_denoiser_filter_sse2(unsigned char* mc_running_avg_y,
+                             int mc_avg_y_stride,
+                             unsigned char* running_avg_y,
+                             int avg_y_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
 #define vp8_denoiser_filter vp8_denoiser_filter_sse2
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_uv_sse2(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+int vp8_denoiser_filter_uv_sse2(unsigned char* mc_running_avg,
+                                int mc_avg_stride,
+                                unsigned char* running_avg,
+                                int avg_stride,
+                                unsigned char* sig,
+                                int sig_stride,
+                                unsigned int motion_magnitude,
+                                int increase_denoising);
 #define vp8_denoiser_filter_uv vp8_denoiser_filter_uv_sse2
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
-void vp8_dequant_idct_add_mmx(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
+void vp8_dequant_idct_add_mmx(short* input,
+                              short* dq,
+                              unsigned char* output,
+                              int stride);
 #define vp8_dequant_idct_add vp8_dequant_idct_add_mmx
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-void vp8_dequant_idct_add_uv_block_sse2(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
+void vp8_dequant_idct_add_uv_block_sse2(short* q,
+                                        short* dq,
+                                        unsigned char* dst_u,
+                                        unsigned char* dst_v,
+                                        int stride,
+                                        char* eobs);
 #define vp8_dequant_idct_add_uv_block vp8_dequant_idct_add_uv_block_sse2
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-void vp8_dequant_idct_add_y_block_sse2(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
+void vp8_dequant_idct_add_y_block_sse2(short* q,
+                                       short* dq,
+                                       unsigned char* dst,
+                                       int stride,
+                                       char* eobs);
 #define vp8_dequant_idct_add_y_block vp8_dequant_idct_add_y_block_sse2
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
-void vp8_dequantize_b_mmx(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
+void vp8_dequantize_b_mmx(struct blockd*, short* dqc);
 #define vp8_dequantize_b vp8_dequantize_b_mmx
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_diamond_search_sadx4(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
+int vp8_diamond_search_sadx4(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
 #define vp8_diamond_search_sad vp8_diamond_search_sadx4
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
-void vp8_fast_quantize_b_sse2(struct block *, struct blockd *);
-void vp8_fast_quantize_b_ssse3(struct block *, struct blockd *);
-RTCD_EXTERN void (*vp8_fast_quantize_b)(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
+void vp8_fast_quantize_b_sse2(struct block*, struct blockd*);
+void vp8_fast_quantize_b_ssse3(struct block*, struct blockd*);
+RTCD_EXTERN void (*vp8_fast_quantize_b)(struct block*, struct blockd*);
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-void vp8_filter_by_weight16x16_sse2(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
+void vp8_filter_by_weight16x16_sse2(unsigned char* src,
+                                    int src_stride,
+                                    unsigned char* dst,
+                                    int dst_stride,
+                                    int src_weight);
 #define vp8_filter_by_weight16x16 vp8_filter_by_weight16x16_sse2
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-void vp8_filter_by_weight8x8_sse2(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
+void vp8_filter_by_weight8x8_sse2(unsigned char* src,
+                                  int src_stride,
+                                  unsigned char* dst,
+                                  int dst_stride,
+                                  int src_weight);
 #define vp8_filter_by_weight8x8 vp8_filter_by_weight8x8_sse2
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_full_search_sadx3(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_full_search_sadx8(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-RTCD_EXTERN int (*vp8_full_search_sad)(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+int vp8_full_search_sadx3(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+int vp8_full_search_sadx8(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+RTCD_EXTERN int (*vp8_full_search_sad)(struct macroblock* x,
+                                       struct block* b,
+                                       struct blockd* d,
+                                       union int_mv* ref_mv,
+                                       int sad_per_bit,
+                                       int distance,
+                                       struct variance_vtable* fn_ptr,
+                                       int* mvcost[2],
+                                       union int_mv* center_mv);
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bh_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bh_sse2(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
 #define vp8_loop_filter_bh vp8_loop_filter_bh_sse2
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bv_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bv_sse2(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
 #define vp8_loop_filter_bv vp8_loop_filter_bv_sse2
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbh_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbh_sse2(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbh vp8_loop_filter_mbh_sse2
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbv_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbv_sse2(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbv vp8_loop_filter_mbv_sse2
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bhs_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bhs_sse2(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_bh vp8_loop_filter_bhs_sse2
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bvs_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bvs_sse2(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_bv vp8_loop_filter_bvs_sse2
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_simple_horizontal_edge_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
+void vp8_loop_filter_simple_horizontal_edge_sse2(unsigned char* y,
+                                                 int ystride,
+                                                 const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbh vp8_loop_filter_simple_horizontal_edge_sse2
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_simple_vertical_edge_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
+void vp8_loop_filter_simple_vertical_edge_sse2(unsigned char* y,
+                                               int ystride,
+                                               const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbv vp8_loop_filter_simple_vertical_edge_sse2
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
-int vp8_mbblock_error_sse2(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
+int vp8_mbblock_error_sse2(struct macroblock* mb, int dc);
 #define vp8_mbblock_error vp8_mbblock_error_sse2
 
-int vp8_mbuverror_c(struct macroblock *mb);
-int vp8_mbuverror_sse2(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
+int vp8_mbuverror_sse2(struct macroblock* mb);
 #define vp8_mbuverror vp8_mbuverror_sse2
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_refining_search_sadx4(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
+int vp8_refining_search_sadx4(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
 #define vp8_refining_search_sad vp8_refining_search_sadx4
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
-void vp8_regular_quantize_b_sse2(struct block *, struct blockd *);
-void vp8_regular_quantize_b_sse4_1(struct block *, struct blockd *);
-RTCD_EXTERN void (*vp8_regular_quantize_b)(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
+void vp8_regular_quantize_b_sse2(struct block*, struct blockd*);
+void vp8_regular_quantize_b_sse4_1(struct block*, struct blockd*);
+RTCD_EXTERN void (*vp8_regular_quantize_b)(struct block*, struct blockd*);
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct4x4_sse2(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct4x4_sse2(short* input, short* output, int pitch);
 #define vp8_short_fdct4x4 vp8_short_fdct4x4_sse2
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct8x4_sse2(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct8x4_sse2(short* input, short* output, int pitch);
 #define vp8_short_fdct8x4 vp8_short_fdct8x4_sse2
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-void vp8_short_idct4x4llm_mmx(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_short_idct4x4llm_mmx(short* input,
+                              unsigned char* pred,
+                              int pitch,
+                              unsigned char* dst,
+                              int dst_stride);
 #define vp8_short_idct4x4llm vp8_short_idct4x4llm_mmx
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
-void vp8_short_inv_walsh4x4_sse2(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
+void vp8_short_inv_walsh4x4_sse2(short* input, short* output);
 #define vp8_short_inv_walsh4x4 vp8_short_inv_walsh4x4_sse2
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
-void vp8_short_walsh4x4_sse2(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
+void vp8_short_walsh4x4_sse2(short* input, short* output, int pitch);
 #define vp8_short_walsh4x4 vp8_short_walsh4x4_sse2
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict16x16)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict16x16_sse2(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+void vp8_sixtap_predict16x16_ssse3(unsigned char* src,
+                                   int src_pitch,
+                                   int xofst,
+                                   int yofst,
+                                   unsigned char* dst,
+                                   int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict16x16)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict4x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict4x4_mmx(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict4x4_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict4x4)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict8x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x4_sse2(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+void vp8_sixtap_predict8x4_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict8x4)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict8x8)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x8_sse2(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+void vp8_sixtap_predict8x8_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict8x8)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
 void vp8_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_sse2;
-    if (flags & HAS_SSSE3) vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_ssse3;
-    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_sse2;
-    if (flags & HAS_SSSE3) vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_ssse3;
-    vp8_copy32xn = vp8_copy32xn_sse2;
-    if (flags & HAS_SSE3) vp8_copy32xn = vp8_copy32xn_sse3;
-    vp8_fast_quantize_b = vp8_fast_quantize_b_sse2;
-    if (flags & HAS_SSSE3) vp8_fast_quantize_b = vp8_fast_quantize_b_ssse3;
-    vp8_full_search_sad = vp8_full_search_sad_c;
-    if (flags & HAS_SSE3) vp8_full_search_sad = vp8_full_search_sadx3;
-    if (flags & HAS_SSE4_1) vp8_full_search_sad = vp8_full_search_sadx8;
-    vp8_regular_quantize_b = vp8_regular_quantize_b_sse2;
-    if (flags & HAS_SSE4_1) vp8_regular_quantize_b = vp8_regular_quantize_b_sse4_1;
-    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_ssse3;
-    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_mmx;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_ssse3;
-    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_ssse3;
-    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_ssse3;
+  vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_ssse3;
+  vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_ssse3;
+  vp8_copy32xn = vp8_copy32xn_sse2;
+  if (flags & HAS_SSE3)
+    vp8_copy32xn = vp8_copy32xn_sse3;
+  vp8_fast_quantize_b = vp8_fast_quantize_b_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_fast_quantize_b = vp8_fast_quantize_b_ssse3;
+  vp8_full_search_sad = vp8_full_search_sad_c;
+  if (flags & HAS_SSE3)
+    vp8_full_search_sad = vp8_full_search_sadx3;
+  if (flags & HAS_SSE4_1)
+    vp8_full_search_sad = vp8_full_search_sadx8;
+  vp8_regular_quantize_b = vp8_regular_quantize_b_sse2;
+  if (flags & HAS_SSE4_1)
+    vp8_regular_quantize_b = vp8_regular_quantize_b_sse4_1;
+  vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_ssse3;
+  vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_mmx;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_ssse3;
+  vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_ssse3;
+  vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_ssse3;
 }
 #endif
 

third_party/libvpx/source/config/linux/x64/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/x64/vp9_rtcd.h b/third_party/libvpx/source/config/linux/x64/vp9_rtcd.h
index 415d6be..b985873 100644
--- a/third_party/libvpx/source/config/linux/x64/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/linux/x64/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,147 +30,474 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-int64_t vp9_block_error_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-int64_t vp9_block_error_avx2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-RTCD_EXTERN int64_t (*vp9_block_error)(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
+int64_t vp9_block_error_sse2(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             intptr_t block_size,
+                             int64_t* ssz);
+int64_t vp9_block_error_avx2(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             intptr_t block_size,
+                             int64_t* ssz);
+RTCD_EXTERN int64_t (*vp9_block_error)(const tran_low_t* coeff,
+                                       const tran_low_t* dqcoeff,
+                                       intptr_t block_size,
+                                       int64_t* ssz);
 
-int64_t vp9_block_error_fp_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
-int64_t vp9_block_error_fp_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             int block_size);
+int64_t vp9_block_error_fp_sse2(const tran_low_t* coeff,
+                                const tran_low_t* dqcoeff,
+                                int block_size);
 #define vp9_block_error_fp vp9_block_error_fp_sse2
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-int vp9_denoiser_filter_sse2(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
+int vp9_denoiser_filter_sse2(const uint8_t* sig,
+                             int sig_stride,
+                             const uint8_t* mc_avg,
+                             int mc_avg_stride,
+                             uint8_t* avg,
+                             int avg_stride,
+                             int increase_denoising,
+                             BLOCK_SIZE bs,
+                             int motion_magnitude);
 #define vp9_denoiser_filter vp9_denoiser_filter_sse2
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
-int vp9_diamond_search_sad_avx(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
-RTCD_EXTERN int (*vp9_diamond_search_sad)(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
+int vp9_diamond_search_sad_avx(const struct macroblock* x,
+                               const struct search_site_config* cfg,
+                               struct mv* ref_mv,
+                               struct mv* best_mv,
+                               int search_param,
+                               int sad_per_bit,
+                               int* num00,
+                               const struct vp9_variance_vtable* fn_ptr,
+                               const struct mv* center_mv);
+RTCD_EXTERN int (*vp9_diamond_search_sad)(
+    const struct macroblock* x,
+    const struct search_site_config* cfg,
+    struct mv* ref_mv,
+    struct mv* best_mv,
+    int search_param,
+    int sad_per_bit,
+    int* num00,
+    const struct vp9_variance_vtable* fn_ptr,
+    const struct mv* center_mv);
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_fdct8x8_quant_ssse3(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_fdct8x8_quant)(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+void vp9_fdct8x8_quant_ssse3(const int16_t* input,
+                             int stride,
+                             tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+RTCD_EXTERN void (*vp9_fdct8x8_quant)(const int16_t* input,
+                                      int stride,
+                                      tran_low_t* coeff_ptr,
+                                      intptr_t n_coeffs,
+                                      int skip_block,
+                                      const int16_t* round_ptr,
+                                      const int16_t* quant_ptr,
+                                      tran_low_t* qcoeff_ptr,
+                                      tran_low_t* dqcoeff_ptr,
+                                      const int16_t* dequant_ptr,
+                                      uint16_t* eob_ptr,
+                                      const int16_t* scan,
+                                      const int16_t* iscan);
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht16x16_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
+void vp9_fht16x16_sse2(const int16_t* input,
+                       tran_low_t* output,
+                       int stride,
+                       int tx_type);
 #define vp9_fht16x16 vp9_fht16x16_sse2
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht4x4_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
+void vp9_fht4x4_sse2(const int16_t* input,
+                     tran_low_t* output,
+                     int stride,
+                     int tx_type);
 #define vp9_fht4x4 vp9_fht4x4_sse2
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht8x8_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
+void vp9_fht8x8_sse2(const int16_t* input,
+                     tran_low_t* output,
+                     int stride,
+                     int tx_type);
 #define vp9_fht8x8 vp9_fht8x8_sse2
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-void vp9_filter_by_weight16x16_sse2(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
+void vp9_filter_by_weight16x16_sse2(const uint8_t* src,
+                                    int src_stride,
+                                    uint8_t* dst,
+                                    int dst_stride,
+                                    int src_weight);
 #define vp9_filter_by_weight16x16 vp9_filter_by_weight16x16_sse2
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-void vp9_filter_by_weight8x8_sse2(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
+void vp9_filter_by_weight8x8_sse2(const uint8_t* src,
+                                  int src_stride,
+                                  uint8_t* dst,
+                                  int dst_stride,
+                                  int src_weight);
 #define vp9_filter_by_weight8x8 vp9_filter_by_weight8x8_sse2
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vp9_fwht4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vp9_fwht4x4_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_fwht4x4 vp9_fwht4x4_sse2
 
-int64_t vp9_highbd_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
-int64_t vp9_highbd_block_error_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
+int64_t vp9_highbd_block_error_c(const tran_low_t* coeff,
+                                 const tran_low_t* dqcoeff,
+                                 intptr_t block_size,
+                                 int64_t* ssz,
+                                 int bd);
+int64_t vp9_highbd_block_error_sse2(const tran_low_t* coeff,
+                                    const tran_low_t* dqcoeff,
+                                    intptr_t block_size,
+                                    int64_t* ssz,
+                                    int bd);
 #define vp9_highbd_block_error vp9_highbd_block_error_sse2
 
-void vp9_highbd_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht16x16_c(const int16_t* input,
+                           tran_low_t* output,
+                           int stride,
+                           int tx_type);
 #define vp9_highbd_fht16x16 vp9_highbd_fht16x16_c
 
-void vp9_highbd_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht4x4_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht4x4 vp9_highbd_fht4x4_c
 
-void vp9_highbd_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht8x8_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht8x8 vp9_highbd_fht8x8_c
 
-void vp9_highbd_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_highbd_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_highbd_fwht4x4 vp9_highbd_fwht4x4_c
 
-void vp9_highbd_iht16x16_256_add_c(const tran_low_t *input, uint16_t *output, int pitch, int tx_type, int bd);
+void vp9_highbd_iht16x16_256_add_c(const tran_low_t* input,
+                                   uint16_t* output,
+                                   int pitch,
+                                   int tx_type,
+                                   int bd);
 #define vp9_highbd_iht16x16_256_add vp9_highbd_iht16x16_256_add_c
 
-void vp9_highbd_iht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht4x4_16_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht4x4_16_add vp9_highbd_iht4x4_16_add_c
 
-void vp9_highbd_iht8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht8x8_64_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht8x8_64_add vp9_highbd_iht8x8_64_add_c
 
-void vp9_highbd_mbpost_proc_across_ip_c(uint16_t *src, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_across_ip_c(uint16_t* src,
+                                        int pitch,
+                                        int rows,
+                                        int cols,
+                                        int flimit);
 #define vp9_highbd_mbpost_proc_across_ip vp9_highbd_mbpost_proc_across_ip_c
 
-void vp9_highbd_mbpost_proc_down_c(uint16_t *dst, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_down_c(uint16_t* dst,
+                                   int pitch,
+                                   int rows,
+                                   int cols,
+                                   int flimit);
 #define vp9_highbd_mbpost_proc_down vp9_highbd_mbpost_proc_down_c
 
-void vp9_highbd_post_proc_down_and_across_c(const uint16_t *src_ptr, uint16_t *dst_ptr, int src_pixels_per_line, int dst_pixels_per_line, int rows, int cols, int flimit);
-#define vp9_highbd_post_proc_down_and_across vp9_highbd_post_proc_down_and_across_c
+void vp9_highbd_post_proc_down_and_across_c(const uint16_t* src_ptr,
+                                            uint16_t* dst_ptr,
+                                            int src_pixels_per_line,
+                                            int dst_pixels_per_line,
+                                            int rows,
+                                            int cols,
+                                            int flimit);
+#define vp9_highbd_post_proc_down_and_across \
+  vp9_highbd_post_proc_down_and_across_c
 
-void vp9_highbd_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_c(const tran_low_t* coeff_ptr,
+                              intptr_t n_coeffs,
+                              int skip_block,
+                              const int16_t* round_ptr,
+                              const int16_t* quant_ptr,
+                              tran_low_t* qcoeff_ptr,
+                              tran_low_t* dqcoeff_ptr,
+                              const int16_t* dequant_ptr,
+                              uint16_t* eob_ptr,
+                              const int16_t* scan,
+                              const int16_t* iscan);
 #define vp9_highbd_quantize_fp vp9_highbd_quantize_fp_c
 
-void vp9_highbd_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 #define vp9_highbd_quantize_fp_32x32 vp9_highbd_quantize_fp_32x32_c
 
-void vp9_highbd_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_highbd_temporal_filter_apply_c(const uint8_t* frame1,
+                                        unsigned int stride,
+                                        const uint8_t* frame2,
+                                        unsigned int block_width,
+                                        unsigned int block_height,
+                                        int strength,
+                                        int filter_weight,
+                                        uint32_t* accumulator,
+                                        uint16_t* count);
 #define vp9_highbd_temporal_filter_apply vp9_highbd_temporal_filter_apply_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
-void vp9_iht16x16_256_add_sse2(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
+void vp9_iht16x16_256_add_sse2(const tran_low_t* input,
+                               uint8_t* output,
+                               int pitch,
+                               int tx_type);
 #define vp9_iht16x16_256_add vp9_iht16x16_256_add_sse2
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht4x4_16_add_sse2(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
 #define vp9_iht4x4_16_add vp9_iht4x4_16_add_sse2
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht8x8_64_add_sse2(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht8x8_64_add_sse2(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
 #define vp9_iht8x8_64_add vp9_iht8x8_64_add_sse2
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_ssse3(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_quantize_fp)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
+void vp9_quantize_fp_sse2(const tran_low_t* coeff_ptr,
+                          intptr_t n_coeffs,
+                          int skip_block,
+                          const int16_t* round_ptr,
+                          const int16_t* quant_ptr,
+                          tran_low_t* qcoeff_ptr,
+                          tran_low_t* dqcoeff_ptr,
+                          const int16_t* dequant_ptr,
+                          uint16_t* eob_ptr,
+                          const int16_t* scan,
+                          const int16_t* iscan);
+void vp9_quantize_fp_ssse3(const tran_low_t* coeff_ptr,
+                           intptr_t n_coeffs,
+                           int skip_block,
+                           const int16_t* round_ptr,
+                           const int16_t* quant_ptr,
+                           tran_low_t* qcoeff_ptr,
+                           tran_low_t* dqcoeff_ptr,
+                           const int16_t* dequant_ptr,
+                           uint16_t* eob_ptr,
+                           const int16_t* scan,
+                           const int16_t* iscan);
+RTCD_EXTERN void (*vp9_quantize_fp)(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_32x32_ssse3(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_quantize_fp_32x32)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+void vp9_quantize_fp_32x32_ssse3(const tran_low_t* coeff_ptr,
+                                 intptr_t n_coeffs,
+                                 int skip_block,
+                                 const int16_t* round_ptr,
+                                 const int16_t* quant_ptr,
+                                 tran_low_t* qcoeff_ptr,
+                                 tran_low_t* dqcoeff_ptr,
+                                 const int16_t* dequant_ptr,
+                                 uint16_t* eob_ptr,
+                                 const int16_t* scan,
+                                 const int16_t* iscan);
+RTCD_EXTERN void (*vp9_quantize_fp_32x32)(const tran_low_t* coeff_ptr,
+                                          intptr_t n_coeffs,
+                                          int skip_block,
+                                          const int16_t* round_ptr,
+                                          const int16_t* quant_ptr,
+                                          tran_low_t* qcoeff_ptr,
+                                          tran_low_t* dqcoeff_ptr,
+                                          const int16_t* dequant_ptr,
+                                          uint16_t* eob_ptr,
+                                          const int16_t* scan,
+                                          const int16_t* iscan);
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
-void vp9_scale_and_extend_frame_ssse3(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
-RTCD_EXTERN void (*vp9_scale_and_extend_frame)(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
+void vp9_scale_and_extend_frame_ssse3(const struct yv12_buffer_config* src,
+                                      struct yv12_buffer_config* dst,
+                                      INTERP_FILTER filter_type,
+                                      int phase_scaler);
+RTCD_EXTERN void (*vp9_scale_and_extend_frame)(
+    const struct yv12_buffer_config* src,
+    struct yv12_buffer_config* dst,
+    INTERP_FILTER filter_type,
+    int phase_scaler);
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
-void vp9_temporal_filter_apply_sse4_1(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
-RTCD_EXTERN void (*vp9_temporal_filter_apply)(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
+void vp9_temporal_filter_apply_sse4_1(const uint8_t* frame1,
+                                      unsigned int stride,
+                                      const uint8_t* frame2,
+                                      unsigned int block_width,
+                                      unsigned int block_height,
+                                      int strength,
+                                      int filter_weight,
+                                      uint32_t* accumulator,
+                                      uint16_t* count);
+RTCD_EXTERN void (*vp9_temporal_filter_apply)(const uint8_t* frame1,
+                                              unsigned int stride,
+                                              const uint8_t* frame2,
+                                              unsigned int block_width,
+                                              unsigned int block_height,
+                                              int strength,
+                                              int filter_weight,
+                                              uint32_t* accumulator,
+                                              uint16_t* count);
 
 void vp9_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vp9_block_error = vp9_block_error_sse2;
-    if (flags & HAS_AVX2) vp9_block_error = vp9_block_error_avx2;
-    vp9_diamond_search_sad = vp9_diamond_search_sad_c;
-    if (flags & HAS_AVX) vp9_diamond_search_sad = vp9_diamond_search_sad_avx;
-    vp9_fdct8x8_quant = vp9_fdct8x8_quant_c;
-    if (flags & HAS_SSSE3) vp9_fdct8x8_quant = vp9_fdct8x8_quant_ssse3;
-    vp9_quantize_fp = vp9_quantize_fp_sse2;
-    if (flags & HAS_SSSE3) vp9_quantize_fp = vp9_quantize_fp_ssse3;
-    vp9_quantize_fp_32x32 = vp9_quantize_fp_32x32_c;
-    if (flags & HAS_SSSE3) vp9_quantize_fp_32x32 = vp9_quantize_fp_32x32_ssse3;
-    vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_c;
-    if (flags & HAS_SSSE3) vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_ssse3;
-    vp9_temporal_filter_apply = vp9_temporal_filter_apply_c;
-    if (flags & HAS_SSE4_1) vp9_temporal_filter_apply = vp9_temporal_filter_apply_sse4_1;
+  vp9_block_error = vp9_block_error_sse2;
+  if (flags & HAS_AVX2)
+    vp9_block_error = vp9_block_error_avx2;
+  vp9_diamond_search_sad = vp9_diamond_search_sad_c;
+  if (flags & HAS_AVX)
+    vp9_diamond_search_sad = vp9_diamond_search_sad_avx;
+  vp9_fdct8x8_quant = vp9_fdct8x8_quant_c;
+  if (flags & HAS_SSSE3)
+    vp9_fdct8x8_quant = vp9_fdct8x8_quant_ssse3;
+  vp9_quantize_fp = vp9_quantize_fp_sse2;
+  if (flags & HAS_SSSE3)
+    vp9_quantize_fp = vp9_quantize_fp_ssse3;
+  vp9_quantize_fp_32x32 = vp9_quantize_fp_32x32_c;
+  if (flags & HAS_SSSE3)
+    vp9_quantize_fp_32x32 = vp9_quantize_fp_32x32_ssse3;
+  vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_c;
+  if (flags & HAS_SSSE3)
+    vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_ssse3;
+  vp9_temporal_filter_apply = vp9_temporal_filter_apply_c;
+  if (flags & HAS_SSE4_1)
+    vp9_temporal_filter_apply = vp9_temporal_filter_apply_sse4_1;
 }
 #endif
 

third_party/libvpx/source/config/linux/x64/vpx_config.asm

diff --git a/third_party/libvpx/source/config/linux/x64/vpx_config.asm b/third_party/libvpx/source/config/linux/x64/vpx_config.asm
index d780d20..514d721 100644
--- a/third_party/libvpx/source/config/linux/x64/vpx_config.asm
+++ b/third_party/libvpx/source/config/linux/x64/vpx_config.asm
@@ -18,6 +18,7 @@
 %define HAVE_AVX 1
 %define HAVE_AVX2 1
 %define HAVE_VSX 0
+%define HAVE_MMI 0
 %define HAVE_VPX_PORTS 1
 %define HAVE_PTHREAD_H 1
 %define HAVE_UNISTD_H 0

third_party/libvpx/source/config/linux/x64/vpx_config.h

diff --git a/third_party/libvpx/source/config/linux/x64/vpx_config.h b/third_party/libvpx/source/config/linux/x64/vpx_config.h
index f946228..aae61b5c 100644
--- a/third_party/libvpx/source/config/linux/x64/vpx_config.h
+++ b/third_party/libvpx/source/config/linux/x64/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 1
 #define HAVE_AVX2 1
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/linux/x64/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/x64/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/linux/x64/vpx_dsp_rtcd.h
index 742dbff..05579e2d 100644
--- a/third_party/libvpx/source/config/linux/x64/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/linux/x64/vpx_dsp_rtcd.h
@@ -14,2175 +14,7391 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
-unsigned int vpx_avg_4x4_sse2(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
+unsigned int vpx_avg_4x4_sse2(const uint8_t*, int p);
 #define vpx_avg_4x4 vpx_avg_4x4_sse2
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
-unsigned int vpx_avg_8x8_sse2(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
+unsigned int vpx_avg_8x8_sse2(const uint8_t*, int p);
 #define vpx_avg_8x8 vpx_avg_8x8_sse2
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-void vpx_comp_avg_pred_sse2(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
+void vpx_comp_avg_pred_sse2(uint8_t* comp_pred,
+                            const uint8_t* pred,
+                            int width,
+                            int height,
+                            const uint8_t* ref,
+                            int ref_stride);
 #define vpx_comp_avg_pred vpx_comp_avg_pred_sse2
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_convolve8_sse2(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve8_ssse3(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avx2(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+RTCD_EXTERN void (*vpx_convolve8)(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avg_sse2(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
+void vpx_convolve8_avg_ssse3(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+RTCD_EXTERN void (*vpx_convolve8_avg)(const uint8_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h);
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg_horiz)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_avg_horiz_sse2(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
+void vpx_convolve8_avg_horiz_ssse3(const uint8_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h);
+RTCD_EXTERN void (*vpx_convolve8_avg_horiz)(const uint8_t* src,
+                                            ptrdiff_t src_stride,
+                                            uint8_t* dst,
+                                            ptrdiff_t dst_stride,
+                                            const int16_t* filter_x,
+                                            int x_step_q4,
+                                            const int16_t* filter_y,
+                                            int y_step_q4,
+                                            int w,
+                                            int h);
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg_vert)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_avg_vert_sse2(const uint8_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h);
+void vpx_convolve8_avg_vert_ssse3(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
+RTCD_EXTERN void (*vpx_convolve8_avg_vert)(const uint8_t* src,
+                                           ptrdiff_t src_stride,
+                                           uint8_t* dst,
+                                           ptrdiff_t dst_stride,
+                                           const int16_t* filter_x,
+                                           int x_step_q4,
+                                           const int16_t* filter_y,
+                                           int y_step_q4,
+                                           int w,
+                                           int h);
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_horiz)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+void vpx_convolve8_horiz_sse2(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_horiz_ssse3(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_horiz_avx2(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+RTCD_EXTERN void (*vpx_convolve8_horiz)(const uint8_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint8_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h);
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_vert)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
+void vpx_convolve8_vert_sse2(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+void vpx_convolve8_vert_ssse3(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_vert_avx2(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+RTCD_EXTERN void (*vpx_convolve8_vert)(const uint8_t* src,
+                                       ptrdiff_t src_stride,
+                                       uint8_t* dst,
+                                       ptrdiff_t dst_stride,
+                                       const int16_t* filter_x,
+                                       int x_step_q4,
+                                       const int16_t* filter_y,
+                                       int y_step_q4,
+                                       int w,
+                                       int h);
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_avg_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve_avg_sse2(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_convolve_avg vpx_convolve_avg_sse2
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_copy_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve_copy_sse2(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_convolve_copy vpx_convolve_copy_sse2
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_c
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_c
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_c
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_c
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d153_predictor_16x16_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_16x16)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d153_predictor_32x32_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_32x32)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_4x4_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d153_predictor_4x4_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_4x4)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d153_predictor_8x8_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_8x8)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d207_predictor_16x16_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_16x16)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d207_predictor_32x32_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_32x32)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d207_predictor_4x4_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_d207_predictor_4x4 vpx_d207_predictor_4x4_sse2
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d207_predictor_8x8_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_8x8)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_16x16_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_16x16)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_32x32_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_32x32)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_4x4_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d45_predictor_4x4 vpx_d45_predictor_4x4_sse2
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_8x8_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d45_predictor_8x8 vpx_d45_predictor_8x8_sse2
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d63_predictor_16x16_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_16x16)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d63_predictor_32x32_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_32x32)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_4x4_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d63_predictor_4x4_ssse3(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_4x4)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d63_predictor_8x8_ssse3(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_8x8)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_16x16_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_128_predictor_16x16 vpx_dc_128_predictor_16x16_sse2
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_32x32_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_128_predictor_32x32 vpx_dc_128_predictor_32x32_sse2
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_4x4_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_128_predictor_4x4 vpx_dc_128_predictor_4x4_sse2
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_8x8_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_128_predictor_8x8 vpx_dc_128_predictor_8x8_sse2
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_16x16_sse2(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
 #define vpx_dc_left_predictor_16x16 vpx_dc_left_predictor_16x16_sse2
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_32x32_sse2(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
 #define vpx_dc_left_predictor_32x32 vpx_dc_left_predictor_32x32_sse2
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_4x4_sse2(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
 #define vpx_dc_left_predictor_4x4 vpx_dc_left_predictor_4x4_sse2
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_8x8_sse2(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
 #define vpx_dc_left_predictor_8x8 vpx_dc_left_predictor_8x8_sse2
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_16x16_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_predictor_16x16 vpx_dc_predictor_16x16_sse2
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_32x32_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_predictor_32x32 vpx_dc_predictor_32x32_sse2
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_4x4_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_dc_predictor_4x4 vpx_dc_predictor_4x4_sse2
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_8x8_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_dc_predictor_8x8 vpx_dc_predictor_8x8_sse2
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_16x16_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_top_predictor_16x16 vpx_dc_top_predictor_16x16_sse2
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_32x32_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_top_predictor_32x32 vpx_dc_top_predictor_32x32_sse2
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_4x4_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_top_predictor_4x4 vpx_dc_top_predictor_4x4_sse2
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_8x8_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_top_predictor_8x8 vpx_dc_top_predictor_8x8_sse2
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16 vpx_fdct16x16_sse2
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_1_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_1_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16_1 vpx_fdct16x16_1_sse2
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32 vpx_fdct32x32_sse2
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_1_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_1_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_1 vpx_fdct32x32_1_sse2
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_rd_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_rd_sse2(const int16_t* input,
+                           tran_low_t* output,
+                           int stride);
 #define vpx_fdct32x32_rd vpx_fdct32x32_rd_sse2
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4 vpx_fdct4x4_sse2
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_1_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_1_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4_1 vpx_fdct4x4_1_sse2
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8 vpx_fdct8x8_sse2
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_1_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_1_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8_1 vpx_fdct8x8_1_sse2
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-RTCD_EXTERN void (*vpx_get16x16var)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
+void vpx_get16x16var_sse2(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
+void vpx_get16x16var_avx2(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
+RTCD_EXTERN void (*vpx_get16x16var)(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse,
+                                    int* sum);
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_c
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get8x8var_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
+void vpx_get8x8var_sse2(const uint8_t* src_ptr,
+                        int source_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        unsigned int* sse,
+                        int* sum);
 #define vpx_get8x8var vpx_get8x8var_sse2
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
-unsigned int vpx_get_mb_ss_sse2(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
+unsigned int vpx_get_mb_ss_sse2(const int16_t*);
 #define vpx_get_mb_ss vpx_get_mb_ss_sse2
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_16x16_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_h_predictor_16x16 vpx_h_predictor_16x16_sse2
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_32x32_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_h_predictor_32x32 vpx_h_predictor_32x32_sse2
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_4x4_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_h_predictor_4x4 vpx_h_predictor_4x4_sse2
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_8x8_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_h_predictor_8x8 vpx_h_predictor_8x8_sse2
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_16x16_sse2(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          tran_low_t* coeff);
+void vpx_hadamard_16x16_sse2(const int16_t* src_diff,
+                             int src_stride,
+                             tran_low_t* coeff);
 #define vpx_hadamard_16x16 vpx_hadamard_16x16_sse2
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_8x8_sse2(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_8x8_ssse3(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-RTCD_EXTERN void (*vpx_hadamard_8x8)(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        tran_low_t* coeff);
+void vpx_hadamard_8x8_sse2(const int16_t* src_diff,
+                           int src_stride,
+                           tran_low_t* coeff);
+void vpx_hadamard_8x8_ssse3(const int16_t* src_diff,
+                            int src_stride,
+                            tran_low_t* coeff);
+RTCD_EXTERN void (*vpx_hadamard_8x8)(const int16_t* src_diff,
+                                     int src_stride,
+                                     tran_low_t* coeff);
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_highbd_10_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_10_get16x16var vpx_highbd_10_get16x16var_c
 
-void vpx_highbd_10_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_10_get8x8var vpx_highbd_10_get8x8var_c
 
-unsigned int vpx_highbd_10_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+unsigned int vpx_highbd_10_mse16x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_mse16x16 vpx_highbd_10_mse16x16_sse2
 
-unsigned int vpx_highbd_10_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse16x8 vpx_highbd_10_mse16x8_c
 
-unsigned int vpx_highbd_10_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse8x16 vpx_highbd_10_mse8x16_c
 
-unsigned int vpx_highbd_10_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
+unsigned int vpx_highbd_10_mse8x8_sse2(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
 #define vpx_highbd_10_mse8x8 vpx_highbd_10_mse8x8_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x16 vpx_highbd_10_sub_pixel_avg_variance16x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x16 \
+  vpx_highbd_10_sub_pixel_avg_variance16x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x32 vpx_highbd_10_sub_pixel_avg_variance16x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x32 \
+  vpx_highbd_10_sub_pixel_avg_variance16x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x8 vpx_highbd_10_sub_pixel_avg_variance16x8_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x8 \
+  vpx_highbd_10_sub_pixel_avg_variance16x8_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x16 vpx_highbd_10_sub_pixel_avg_variance32x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x16 \
+  vpx_highbd_10_sub_pixel_avg_variance32x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x32 vpx_highbd_10_sub_pixel_avg_variance32x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x32 \
+  vpx_highbd_10_sub_pixel_avg_variance32x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x64 vpx_highbd_10_sub_pixel_avg_variance32x64_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x64 \
+  vpx_highbd_10_sub_pixel_avg_variance32x64_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x4 vpx_highbd_10_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x4 \
+  vpx_highbd_10_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x8 vpx_highbd_10_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x8 \
+  vpx_highbd_10_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance64x32 vpx_highbd_10_sub_pixel_avg_variance64x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance64x32 \
+  vpx_highbd_10_sub_pixel_avg_variance64x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance64x64 vpx_highbd_10_sub_pixel_avg_variance64x64_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance64x64 \
+  vpx_highbd_10_sub_pixel_avg_variance64x64_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x16 vpx_highbd_10_sub_pixel_avg_variance8x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x16 \
+  vpx_highbd_10_sub_pixel_avg_variance8x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x4 vpx_highbd_10_sub_pixel_avg_variance8x4_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x4 \
+  vpx_highbd_10_sub_pixel_avg_variance8x4_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x8 vpx_highbd_10_sub_pixel_avg_variance8x8_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x8 \
+  vpx_highbd_10_sub_pixel_avg_variance8x8_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x16 vpx_highbd_10_sub_pixel_variance16x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x16 \
+  vpx_highbd_10_sub_pixel_variance16x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x32 vpx_highbd_10_sub_pixel_variance16x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x32 \
+  vpx_highbd_10_sub_pixel_variance16x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x8 vpx_highbd_10_sub_pixel_variance16x8_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x8 \
+  vpx_highbd_10_sub_pixel_variance16x8_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x16 vpx_highbd_10_sub_pixel_variance32x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x16 \
+  vpx_highbd_10_sub_pixel_variance32x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x32 vpx_highbd_10_sub_pixel_variance32x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x32 \
+  vpx_highbd_10_sub_pixel_variance32x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x64 vpx_highbd_10_sub_pixel_variance32x64_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x64 \
+  vpx_highbd_10_sub_pixel_variance32x64_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x4 vpx_highbd_10_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x4 \
+  vpx_highbd_10_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x8 vpx_highbd_10_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x8 \
+  vpx_highbd_10_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance64x32 vpx_highbd_10_sub_pixel_variance64x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance64x32 \
+  vpx_highbd_10_sub_pixel_variance64x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance64x64 vpx_highbd_10_sub_pixel_variance64x64_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance64x64 \
+  vpx_highbd_10_sub_pixel_variance64x64_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x16 vpx_highbd_10_sub_pixel_variance8x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x16 \
+  vpx_highbd_10_sub_pixel_variance8x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x4 vpx_highbd_10_sub_pixel_variance8x4_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x4 \
+  vpx_highbd_10_sub_pixel_variance8x4_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x8 vpx_highbd_10_sub_pixel_variance8x8_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x8 \
+  vpx_highbd_10_sub_pixel_variance8x8_sse2
 
-unsigned int vpx_highbd_10_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance16x16 vpx_highbd_10_variance16x16_sse2
 
-unsigned int vpx_highbd_10_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance16x32 vpx_highbd_10_variance16x32_sse2
 
-unsigned int vpx_highbd_10_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_10_variance16x8 vpx_highbd_10_variance16x8_sse2
 
-unsigned int vpx_highbd_10_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance32x16 vpx_highbd_10_variance32x16_sse2
 
-unsigned int vpx_highbd_10_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance32x32 vpx_highbd_10_variance32x32_sse2
 
-unsigned int vpx_highbd_10_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance32x64 vpx_highbd_10_variance32x64_sse2
 
-unsigned int vpx_highbd_10_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x4 vpx_highbd_10_variance4x4_c
 
-unsigned int vpx_highbd_10_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x8 vpx_highbd_10_variance4x8_c
 
-unsigned int vpx_highbd_10_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance64x32 vpx_highbd_10_variance64x32_sse2
 
-unsigned int vpx_highbd_10_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance64x64 vpx_highbd_10_variance64x64_sse2
 
-unsigned int vpx_highbd_10_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_10_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_10_variance8x16 vpx_highbd_10_variance8x16_sse2
 
-unsigned int vpx_highbd_10_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance8x4 vpx_highbd_10_variance8x4_c
 
-unsigned int vpx_highbd_10_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_10_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 #define vpx_highbd_10_variance8x8 vpx_highbd_10_variance8x8_sse2
 
-void vpx_highbd_12_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_12_get16x16var vpx_highbd_12_get16x16var_c
 
-void vpx_highbd_12_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_12_get8x8var vpx_highbd_12_get8x8var_c
 
-unsigned int vpx_highbd_12_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+unsigned int vpx_highbd_12_mse16x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_mse16x16 vpx_highbd_12_mse16x16_sse2
 
-unsigned int vpx_highbd_12_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse16x8 vpx_highbd_12_mse16x8_c
 
-unsigned int vpx_highbd_12_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse8x16 vpx_highbd_12_mse8x16_c
 
-unsigned int vpx_highbd_12_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
+unsigned int vpx_highbd_12_mse8x8_sse2(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
 #define vpx_highbd_12_mse8x8 vpx_highbd_12_mse8x8_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x16 vpx_highbd_12_sub_pixel_avg_variance16x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x16 \
+  vpx_highbd_12_sub_pixel_avg_variance16x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x32 vpx_highbd_12_sub_pixel_avg_variance16x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x32 \
+  vpx_highbd_12_sub_pixel_avg_variance16x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x8 vpx_highbd_12_sub_pixel_avg_variance16x8_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x8 \
+  vpx_highbd_12_sub_pixel_avg_variance16x8_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x16 vpx_highbd_12_sub_pixel_avg_variance32x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x16 \
+  vpx_highbd_12_sub_pixel_avg_variance32x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x32 vpx_highbd_12_sub_pixel_avg_variance32x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x32 \
+  vpx_highbd_12_sub_pixel_avg_variance32x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x64 vpx_highbd_12_sub_pixel_avg_variance32x64_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x64 \
+  vpx_highbd_12_sub_pixel_avg_variance32x64_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x4 vpx_highbd_12_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x4 \
+  vpx_highbd_12_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x8 vpx_highbd_12_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x8 \
+  vpx_highbd_12_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance64x32 vpx_highbd_12_sub_pixel_avg_variance64x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance64x32 \
+  vpx_highbd_12_sub_pixel_avg_variance64x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance64x64 vpx_highbd_12_sub_pixel_avg_variance64x64_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance64x64 \
+  vpx_highbd_12_sub_pixel_avg_variance64x64_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x16 vpx_highbd_12_sub_pixel_avg_variance8x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x16 \
+  vpx_highbd_12_sub_pixel_avg_variance8x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x4 vpx_highbd_12_sub_pixel_avg_variance8x4_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x4 \
+  vpx_highbd_12_sub_pixel_avg_variance8x4_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x8 vpx_highbd_12_sub_pixel_avg_variance8x8_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x8 \
+  vpx_highbd_12_sub_pixel_avg_variance8x8_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x16 vpx_highbd_12_sub_pixel_variance16x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x16 \
+  vpx_highbd_12_sub_pixel_variance16x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x32 vpx_highbd_12_sub_pixel_variance16x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x32 \
+  vpx_highbd_12_sub_pixel_variance16x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x8 vpx_highbd_12_sub_pixel_variance16x8_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x8 \
+  vpx_highbd_12_sub_pixel_variance16x8_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x16 vpx_highbd_12_sub_pixel_variance32x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x16 \
+  vpx_highbd_12_sub_pixel_variance32x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x32 vpx_highbd_12_sub_pixel_variance32x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x32 \
+  vpx_highbd_12_sub_pixel_variance32x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x64 vpx_highbd_12_sub_pixel_variance32x64_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x64 \
+  vpx_highbd_12_sub_pixel_variance32x64_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x4 vpx_highbd_12_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x4 \
+  vpx_highbd_12_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x8 vpx_highbd_12_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x8 \
+  vpx_highbd_12_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance64x32 vpx_highbd_12_sub_pixel_variance64x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance64x32 \
+  vpx_highbd_12_sub_pixel_variance64x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance64x64 vpx_highbd_12_sub_pixel_variance64x64_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance64x64 \
+  vpx_highbd_12_sub_pixel_variance64x64_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x16 vpx_highbd_12_sub_pixel_variance8x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x16 \
+  vpx_highbd_12_sub_pixel_variance8x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x4 vpx_highbd_12_sub_pixel_variance8x4_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x4 \
+  vpx_highbd_12_sub_pixel_variance8x4_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x8 vpx_highbd_12_sub_pixel_variance8x8_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x8 \
+  vpx_highbd_12_sub_pixel_variance8x8_sse2
 
-unsigned int vpx_highbd_12_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance16x16 vpx_highbd_12_variance16x16_sse2
 
-unsigned int vpx_highbd_12_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance16x32 vpx_highbd_12_variance16x32_sse2
 
-unsigned int vpx_highbd_12_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_12_variance16x8 vpx_highbd_12_variance16x8_sse2
 
-unsigned int vpx_highbd_12_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance32x16 vpx_highbd_12_variance32x16_sse2
 
-unsigned int vpx_highbd_12_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance32x32 vpx_highbd_12_variance32x32_sse2
 
-unsigned int vpx_highbd_12_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance32x64 vpx_highbd_12_variance32x64_sse2
 
-unsigned int vpx_highbd_12_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x4 vpx_highbd_12_variance4x4_c
 
-unsigned int vpx_highbd_12_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x8 vpx_highbd_12_variance4x8_c
 
-unsigned int vpx_highbd_12_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance64x32 vpx_highbd_12_variance64x32_sse2
 
-unsigned int vpx_highbd_12_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance64x64 vpx_highbd_12_variance64x64_sse2
 
-unsigned int vpx_highbd_12_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_12_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_12_variance8x16 vpx_highbd_12_variance8x16_sse2
 
-unsigned int vpx_highbd_12_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance8x4 vpx_highbd_12_variance8x4_c
 
-unsigned int vpx_highbd_12_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_12_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 #define vpx_highbd_12_variance8x8 vpx_highbd_12_variance8x8_sse2
 
-void vpx_highbd_8_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get16x16var_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse,
+                                int* sum);
 #define vpx_highbd_8_get16x16var vpx_highbd_8_get16x16var_c
 
-void vpx_highbd_8_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get8x8var_c(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              unsigned int* sse,
+                              int* sum);
 #define vpx_highbd_8_get8x8var vpx_highbd_8_get8x8var_c
 
-unsigned int vpx_highbd_8_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
+unsigned int vpx_highbd_8_mse16x16_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int recon_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_mse16x16 vpx_highbd_8_mse16x16_sse2
 
-unsigned int vpx_highbd_8_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse16x8 vpx_highbd_8_mse16x8_c
 
-unsigned int vpx_highbd_8_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x16_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse8x16 vpx_highbd_8_mse8x16_c
 
-unsigned int vpx_highbd_8_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x8_c(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int recon_stride,
+                                   unsigned int* sse);
+unsigned int vpx_highbd_8_mse8x8_sse2(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
 #define vpx_highbd_8_mse8x8 vpx_highbd_8_mse8x8_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x16 vpx_highbd_8_sub_pixel_avg_variance16x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x16 \
+  vpx_highbd_8_sub_pixel_avg_variance16x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x32 vpx_highbd_8_sub_pixel_avg_variance16x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x32 \
+  vpx_highbd_8_sub_pixel_avg_variance16x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x8 vpx_highbd_8_sub_pixel_avg_variance16x8_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x8 \
+  vpx_highbd_8_sub_pixel_avg_variance16x8_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x16 vpx_highbd_8_sub_pixel_avg_variance32x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x16 \
+  vpx_highbd_8_sub_pixel_avg_variance32x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x32 vpx_highbd_8_sub_pixel_avg_variance32x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x32 \
+  vpx_highbd_8_sub_pixel_avg_variance32x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x64 vpx_highbd_8_sub_pixel_avg_variance32x64_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x64 \
+  vpx_highbd_8_sub_pixel_avg_variance32x64_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x4 vpx_highbd_8_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x4 \
+  vpx_highbd_8_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x8 vpx_highbd_8_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x8 \
+  vpx_highbd_8_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance64x32 vpx_highbd_8_sub_pixel_avg_variance64x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance64x32 \
+  vpx_highbd_8_sub_pixel_avg_variance64x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance64x64 vpx_highbd_8_sub_pixel_avg_variance64x64_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance64x64 \
+  vpx_highbd_8_sub_pixel_avg_variance64x64_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x16 vpx_highbd_8_sub_pixel_avg_variance8x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x16 \
+  vpx_highbd_8_sub_pixel_avg_variance8x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x4 vpx_highbd_8_sub_pixel_avg_variance8x4_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x4 \
+  vpx_highbd_8_sub_pixel_avg_variance8x4_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x8 vpx_highbd_8_sub_pixel_avg_variance8x8_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x8 \
+  vpx_highbd_8_sub_pixel_avg_variance8x8_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x16 vpx_highbd_8_sub_pixel_variance16x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x16 \
+  vpx_highbd_8_sub_pixel_variance16x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x32 vpx_highbd_8_sub_pixel_variance16x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x32 \
+  vpx_highbd_8_sub_pixel_variance16x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x8 vpx_highbd_8_sub_pixel_variance16x8_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x8 \
+  vpx_highbd_8_sub_pixel_variance16x8_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x16 vpx_highbd_8_sub_pixel_variance32x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x16 \
+  vpx_highbd_8_sub_pixel_variance32x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x32 vpx_highbd_8_sub_pixel_variance32x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x32 \
+  vpx_highbd_8_sub_pixel_variance32x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x64 vpx_highbd_8_sub_pixel_variance32x64_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x64 \
+  vpx_highbd_8_sub_pixel_variance32x64_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x4 vpx_highbd_8_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x8 vpx_highbd_8_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance64x32 vpx_highbd_8_sub_pixel_variance64x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance64x32 \
+  vpx_highbd_8_sub_pixel_variance64x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance64x64 vpx_highbd_8_sub_pixel_variance64x64_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance64x64 \
+  vpx_highbd_8_sub_pixel_variance64x64_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance8x16 vpx_highbd_8_sub_pixel_variance8x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance8x16 \
+  vpx_highbd_8_sub_pixel_variance8x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance8x4 vpx_highbd_8_sub_pixel_variance8x4_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance8x4 \
+  vpx_highbd_8_sub_pixel_variance8x4_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance8x8 vpx_highbd_8_sub_pixel_variance8x8_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance8x8 \
+  vpx_highbd_8_sub_pixel_variance8x8_sse2
 
-unsigned int vpx_highbd_8_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance16x16 vpx_highbd_8_variance16x16_sse2
 
-unsigned int vpx_highbd_8_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance16x32 vpx_highbd_8_variance16x32_sse2
 
-unsigned int vpx_highbd_8_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 #define vpx_highbd_8_variance16x8 vpx_highbd_8_variance16x8_sse2
 
-unsigned int vpx_highbd_8_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance32x16 vpx_highbd_8_variance32x16_sse2
 
-unsigned int vpx_highbd_8_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance32x32 vpx_highbd_8_variance32x32_sse2
 
-unsigned int vpx_highbd_8_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x64_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance32x64 vpx_highbd_8_variance32x64_sse2
 
-unsigned int vpx_highbd_8_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x4 vpx_highbd_8_variance4x4_c
 
-unsigned int vpx_highbd_8_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x8 vpx_highbd_8_variance4x8_c
 
-unsigned int vpx_highbd_8_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance64x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance64x32 vpx_highbd_8_variance64x32_sse2
 
-unsigned int vpx_highbd_8_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance64x64_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance64x64 vpx_highbd_8_variance64x64_sse2
 
-unsigned int vpx_highbd_8_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x16_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_8_variance8x16_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 #define vpx_highbd_8_variance8x16 vpx_highbd_8_variance8x16_sse2
 
-unsigned int vpx_highbd_8_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance8x4 vpx_highbd_8_variance8x4_c
 
-unsigned int vpx_highbd_8_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
+unsigned int vpx_highbd_8_variance8x8_sse2(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_8_variance8x8 vpx_highbd_8_variance8x8_sse2
 
-unsigned int vpx_highbd_avg_4x4_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_4x4_c(const uint8_t*, int p);
 #define vpx_highbd_avg_4x4 vpx_highbd_avg_4x4_c
 
-unsigned int vpx_highbd_avg_8x8_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_8x8_c(const uint8_t*, int p);
 #define vpx_highbd_avg_8x8 vpx_highbd_avg_8x8_c
 
-void vpx_highbd_comp_avg_pred_c(uint16_t *comp_pred, const uint8_t *pred8, int width, int height, const uint8_t *ref8, int ref_stride);
+void vpx_highbd_comp_avg_pred_c(uint16_t* comp_pred,
+                                const uint8_t* pred8,
+                                int width,
+                                int height,
+                                const uint8_t* ref8,
+                                int ref_stride);
 #define vpx_highbd_comp_avg_pred vpx_highbd_comp_avg_pred_c
 
-void vpx_highbd_convolve8_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_c(const uint16_t* src,
+                            ptrdiff_t src_stride,
+                            uint16_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h,
+                            int bps);
+void vpx_highbd_convolve8_sse2(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+void vpx_highbd_convolve8_avx2(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8)(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
 
-void vpx_highbd_convolve8_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
+void vpx_highbd_convolve8_avg_sse2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+void vpx_highbd_convolve8_avg_avx2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg)(const uint16_t* src,
+                                             ptrdiff_t src_stride,
+                                             uint16_t* dst,
+                                             ptrdiff_t dst_stride,
+                                             const int16_t* filter_x,
+                                             int x_step_q4,
+                                             const int16_t* filter_y,
+                                             int y_step_q4,
+                                             int w,
+                                             int h,
+                                             int bps);
 
-void vpx_highbd_convolve8_avg_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_horiz_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_horiz_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg_horiz)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_horiz_c(const uint16_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint16_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h,
+                                      int bps);
+void vpx_highbd_convolve8_avg_horiz_sse2(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
+void vpx_highbd_convolve8_avg_horiz_avx2(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg_horiz)(const uint16_t* src,
+                                                   ptrdiff_t src_stride,
+                                                   uint16_t* dst,
+                                                   ptrdiff_t dst_stride,
+                                                   const int16_t* filter_x,
+                                                   int x_step_q4,
+                                                   const int16_t* filter_y,
+                                                   int y_step_q4,
+                                                   int w,
+                                                   int h,
+                                                   int bps);
 
-void vpx_highbd_convolve8_avg_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_vert_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_vert_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg_vert)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_vert_c(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+void vpx_highbd_convolve8_avg_vert_sse2(const uint16_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint16_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h,
+                                        int bps);
+void vpx_highbd_convolve8_avg_vert_avx2(const uint16_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint16_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h,
+                                        int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg_vert)(const uint16_t* src,
+                                                  ptrdiff_t src_stride,
+                                                  uint16_t* dst,
+                                                  ptrdiff_t dst_stride,
+                                                  const int16_t* filter_x,
+                                                  int x_step_q4,
+                                                  const int16_t* filter_y,
+                                                  int y_step_q4,
+                                                  int w,
+                                                  int h,
+                                                  int bps);
 
-void vpx_highbd_convolve8_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_horiz_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_horiz_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_horiz)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_horiz_c(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+void vpx_highbd_convolve8_horiz_sse2(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+void vpx_highbd_convolve8_horiz_avx2(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_horiz)(const uint16_t* src,
+                                               ptrdiff_t src_stride,
+                                               uint16_t* dst,
+                                               ptrdiff_t dst_stride,
+                                               const int16_t* filter_x,
+                                               int x_step_q4,
+                                               const int16_t* filter_y,
+                                               int y_step_q4,
+                                               int w,
+                                               int h,
+                                               int bps);
 
-void vpx_highbd_convolve8_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_vert_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_vert_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_vert)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_vert_c(const uint16_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint16_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h,
+                                 int bps);
+void vpx_highbd_convolve8_vert_sse2(const uint16_t* src,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst,
+                                    ptrdiff_t dst_stride,
+                                    const int16_t* filter_x,
+                                    int x_step_q4,
+                                    const int16_t* filter_y,
+                                    int y_step_q4,
+                                    int w,
+                                    int h,
+                                    int bps);
+void vpx_highbd_convolve8_vert_avx2(const uint16_t* src,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst,
+                                    ptrdiff_t dst_stride,
+                                    const int16_t* filter_x,
+                                    int x_step_q4,
+                                    const int16_t* filter_y,
+                                    int y_step_q4,
+                                    int w,
+                                    int h,
+                                    int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_vert)(const uint16_t* src,
+                                              ptrdiff_t src_stride,
+                                              uint16_t* dst,
+                                              ptrdiff_t dst_stride,
+                                              const int16_t* filter_x,
+                                              int x_step_q4,
+                                              const int16_t* filter_y,
+                                              int y_step_q4,
+                                              int w,
+                                              int h,
+                                              int bps);
 
-void vpx_highbd_convolve_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_avg_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_avg_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve_avg)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_avg_c(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+void vpx_highbd_convolve_avg_sse2(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+void vpx_highbd_convolve_avg_avx2(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve_avg)(const uint16_t* src,
+                                            ptrdiff_t src_stride,
+                                            uint16_t* dst,
+                                            ptrdiff_t dst_stride,
+                                            const int16_t* filter_x,
+                                            int x_step_q4,
+                                            const int16_t* filter_y,
+                                            int y_step_q4,
+                                            int w,
+                                            int h,
+                                            int bps);
 
-void vpx_highbd_convolve_copy_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_copy_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_copy_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve_copy)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_copy_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
+void vpx_highbd_convolve_copy_sse2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+void vpx_highbd_convolve_copy_avx2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve_copy)(const uint16_t* src,
+                                             ptrdiff_t src_stride,
+                                             uint16_t* dst,
+                                             ptrdiff_t dst_stride,
+                                             const int16_t* filter_x,
+                                             int x_step_q4,
+                                             const int16_t* filter_y,
+                                             int y_step_q4,
+                                             int w,
+                                             int h,
+                                             int bps);
 
-void vpx_highbd_d117_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_16x16 vpx_highbd_d117_predictor_16x16_c
 
-void vpx_highbd_d117_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_32x32 vpx_highbd_d117_predictor_32x32_c
 
-void vpx_highbd_d117_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_4x4 vpx_highbd_d117_predictor_4x4_c
 
-void vpx_highbd_d117_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_8x8 vpx_highbd_d117_predictor_8x8_c
 
-void vpx_highbd_d135_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_16x16 vpx_highbd_d135_predictor_16x16_c
 
-void vpx_highbd_d135_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_32x32 vpx_highbd_d135_predictor_32x32_c
 
-void vpx_highbd_d135_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_4x4 vpx_highbd_d135_predictor_4x4_c
 
-void vpx_highbd_d135_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_8x8 vpx_highbd_d135_predictor_8x8_c
 
-void vpx_highbd_d153_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_16x16 vpx_highbd_d153_predictor_16x16_c
 
-void vpx_highbd_d153_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_32x32 vpx_highbd_d153_predictor_32x32_c
 
-void vpx_highbd_d153_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_4x4 vpx_highbd_d153_predictor_4x4_c
 
-void vpx_highbd_d153_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_8x8 vpx_highbd_d153_predictor_8x8_c
 
-void vpx_highbd_d207_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_16x16 vpx_highbd_d207_predictor_16x16_c
 
-void vpx_highbd_d207_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_32x32 vpx_highbd_d207_predictor_32x32_c
 
-void vpx_highbd_d207_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_4x4 vpx_highbd_d207_predictor_4x4_c
 
-void vpx_highbd_d207_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_8x8 vpx_highbd_d207_predictor_8x8_c
 
-void vpx_highbd_d45_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_16x16 vpx_highbd_d45_predictor_16x16_c
 
-void vpx_highbd_d45_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_32x32 vpx_highbd_d45_predictor_32x32_c
 
-void vpx_highbd_d45_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_4x4 vpx_highbd_d45_predictor_4x4_c
 
-void vpx_highbd_d45_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_8x8 vpx_highbd_d45_predictor_8x8_c
 
-void vpx_highbd_d63_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_16x16 vpx_highbd_d63_predictor_16x16_c
 
-void vpx_highbd_d63_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_32x32 vpx_highbd_d63_predictor_32x32_c
 
-void vpx_highbd_d63_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_4x4 vpx_highbd_d63_predictor_4x4_c
 
-void vpx_highbd_d63_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_8x8 vpx_highbd_d63_predictor_8x8_c
 
-void vpx_highbd_dc_128_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_16x16 vpx_highbd_dc_128_predictor_16x16_c
 
-void vpx_highbd_dc_128_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_32x32 vpx_highbd_dc_128_predictor_32x32_c
 
-void vpx_highbd_dc_128_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_4x4 vpx_highbd_dc_128_predictor_4x4_c
 
-void vpx_highbd_dc_128_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_8x8 vpx_highbd_dc_128_predictor_8x8_c
 
-void vpx_highbd_dc_left_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_16x16_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_16x16 vpx_highbd_dc_left_predictor_16x16_c
 
-void vpx_highbd_dc_left_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_32x32_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_32x32 vpx_highbd_dc_left_predictor_32x32_c
 
-void vpx_highbd_dc_left_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_4x4_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_4x4 vpx_highbd_dc_left_predictor_4x4_c
 
-void vpx_highbd_dc_left_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_8x8_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_8x8 vpx_highbd_dc_left_predictor_8x8_c
 
-void vpx_highbd_dc_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_dc_predictor_16x16_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_predictor_16x16 vpx_highbd_dc_predictor_16x16_sse2
 
-void vpx_highbd_dc_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_dc_predictor_32x32_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_predictor_32x32 vpx_highbd_dc_predictor_32x32_sse2
 
-void vpx_highbd_dc_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_dc_predictor_4x4_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_dc_predictor_4x4 vpx_highbd_dc_predictor_4x4_sse2
 
-void vpx_highbd_dc_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_dc_predictor_8x8_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_dc_predictor_8x8 vpx_highbd_dc_predictor_8x8_sse2
 
-void vpx_highbd_dc_top_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_16x16 vpx_highbd_dc_top_predictor_16x16_c
 
-void vpx_highbd_dc_top_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_32x32 vpx_highbd_dc_top_predictor_32x32_c
 
-void vpx_highbd_dc_top_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_4x4 vpx_highbd_dc_top_predictor_4x4_c
 
-void vpx_highbd_dc_top_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_8x8 vpx_highbd_dc_top_predictor_8x8_c
 
-void vpx_highbd_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct16x16_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
+void vpx_highbd_fdct16x16_sse2(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
 #define vpx_highbd_fdct16x16 vpx_highbd_fdct16x16_sse2
 
-void vpx_highbd_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct16x16_1 vpx_highbd_fdct16x16_1_c
 
-void vpx_highbd_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct32x32_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
+void vpx_highbd_fdct32x32_sse2(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
 #define vpx_highbd_fdct32x32 vpx_highbd_fdct32x32_sse2
 
-void vpx_highbd_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct32x32_1 vpx_highbd_fdct32x32_1_c
 
-void vpx_highbd_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct32x32_rd_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_rd_c(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
+void vpx_highbd_fdct32x32_rd_sse2(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 #define vpx_highbd_fdct32x32_rd vpx_highbd_fdct32x32_rd_sse2
 
-void vpx_highbd_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_highbd_fdct4x4_sse2(const int16_t* input,
+                             tran_low_t* output,
+                             int stride);
 #define vpx_highbd_fdct4x4 vpx_highbd_fdct4x4_sse2
 
-void vpx_highbd_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct8x8_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_highbd_fdct8x8_sse2(const int16_t* input,
+                             tran_low_t* output,
+                             int stride);
 #define vpx_highbd_fdct8x8 vpx_highbd_fdct8x8_sse2
 
-void vpx_highbd_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_1_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
 #define vpx_highbd_fdct8x8_1 vpx_highbd_fdct8x8_1_c
 
-void vpx_highbd_h_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_16x16 vpx_highbd_h_predictor_16x16_c
 
-void vpx_highbd_h_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_32x32 vpx_highbd_h_predictor_32x32_c
 
-void vpx_highbd_h_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_4x4 vpx_highbd_h_predictor_4x4_c
 
-void vpx_highbd_h_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_8x8 vpx_highbd_h_predictor_8x8_c
 
-void vpx_highbd_idct16x16_10_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_10_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_10_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+void vpx_highbd_idct16x16_10_add_sse2(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
 #define vpx_highbd_idct16x16_10_add vpx_highbd_idct16x16_10_add_sse2
 
-void vpx_highbd_idct16x16_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
+void vpx_highbd_idct16x16_1_add_sse2(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
 #define vpx_highbd_idct16x16_1_add vpx_highbd_idct16x16_1_add_sse2
 
-void vpx_highbd_idct16x16_256_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_256_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t* input,
+                                       uint16_t* dest,
+                                       int stride,
+                                       int bd);
 #define vpx_highbd_idct16x16_256_add vpx_highbd_idct16x16_256_add_sse2
 
-void vpx_highbd_idct16x16_38_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-#define vpx_highbd_idct16x16_38_add vpx_highbd_idct16x16_256_add_sse2
+void vpx_highbd_idct16x16_38_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+void vpx_highbd_idct16x16_38_add_sse2(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+#define vpx_highbd_idct16x16_38_add vpx_highbd_idct16x16_38_add_sse2
 
-void vpx_highbd_idct32x32_1024_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1024_add_c(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
 #define vpx_highbd_idct32x32_1024_add vpx_highbd_idct32x32_1024_add_c
 
-void vpx_highbd_idct32x32_135_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_135_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
 #define vpx_highbd_idct32x32_135_add vpx_highbd_idct32x32_135_add_c
 
-void vpx_highbd_idct32x32_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct32x32_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
+void vpx_highbd_idct32x32_1_add_sse2(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
 #define vpx_highbd_idct32x32_1_add vpx_highbd_idct32x32_1_add_sse2
 
-void vpx_highbd_idct32x32_34_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_34_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct32x32_34_add vpx_highbd_idct32x32_34_add_c
 
-void vpx_highbd_idct4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_16_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_16_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct4x4_16_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct4x4_16_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct4x4_16_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct4x4_16_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_idct4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
+void vpx_highbd_idct4x4_1_add_sse2(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct4x4_1_add vpx_highbd_idct4x4_1_add_sse2
 
-void vpx_highbd_idct8x8_12_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_12_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_12_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_12_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_12_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct8x8_12_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct8x8_12_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_12_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_idct8x8_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
+void vpx_highbd_idct8x8_1_add_sse2(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct8x8_1_add vpx_highbd_idct8x8_1_add_sse2
 
-void vpx_highbd_idct8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_64_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_64_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_64_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_64_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct8x8_64_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct8x8_64_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_64_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_iwht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
 #define vpx_highbd_iwht4x4_16_add vpx_highbd_iwht4x4_16_add_c
 
-void vpx_highbd_iwht4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
 #define vpx_highbd_iwht4x4_1_add vpx_highbd_iwht4x4_1_add_c
 
-void vpx_highbd_lpf_horizontal_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_16_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_c(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
+void vpx_highbd_lpf_horizontal_16_sse2(uint16_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh,
+                                       int bd);
 #define vpx_highbd_lpf_horizontal_16 vpx_highbd_lpf_horizontal_16_sse2
 
-void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_16_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh,
+                                         int bd);
+void vpx_highbd_lpf_horizontal_16_dual_sse2(uint16_t* s,
+                                            int pitch,
+                                            const uint8_t* blimit,
+                                            const uint8_t* limit,
+                                            const uint8_t* thresh,
+                                            int bd);
 #define vpx_highbd_lpf_horizontal_16_dual vpx_highbd_lpf_horizontal_16_dual_sse2
 
-void vpx_highbd_lpf_horizontal_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_4_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_4_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
+void vpx_highbd_lpf_horizontal_4_sse2(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit,
+                                      const uint8_t* limit,
+                                      const uint8_t* thresh,
+                                      int bd);
 #define vpx_highbd_lpf_horizontal_4 vpx_highbd_lpf_horizontal_4_sse2
 
-void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_horizontal_4_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
+void vpx_highbd_lpf_horizontal_4_dual_sse2(uint16_t* s,
+                                           int pitch,
+                                           const uint8_t* blimit0,
+                                           const uint8_t* limit0,
+                                           const uint8_t* thresh0,
+                                           const uint8_t* blimit1,
+                                           const uint8_t* limit1,
+                                           const uint8_t* thresh1,
+                                           int bd);
 #define vpx_highbd_lpf_horizontal_4_dual vpx_highbd_lpf_horizontal_4_dual_sse2
 
-void vpx_highbd_lpf_horizontal_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_8_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_8_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
+void vpx_highbd_lpf_horizontal_8_sse2(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit,
+                                      const uint8_t* limit,
+                                      const uint8_t* thresh,
+                                      int bd);
 #define vpx_highbd_lpf_horizontal_8 vpx_highbd_lpf_horizontal_8_sse2
 
-void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_horizontal_8_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
+void vpx_highbd_lpf_horizontal_8_dual_sse2(uint16_t* s,
+                                           int pitch,
+                                           const uint8_t* blimit0,
+                                           const uint8_t* limit0,
+                                           const uint8_t* thresh0,
+                                           const uint8_t* blimit1,
+                                           const uint8_t* limit1,
+                                           const uint8_t* thresh1,
+                                           int bd);
 #define vpx_highbd_lpf_horizontal_8_dual vpx_highbd_lpf_horizontal_8_dual_sse2
 
-void vpx_highbd_lpf_vertical_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_16_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_c(uint16_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh,
+                                  int bd);
+void vpx_highbd_lpf_vertical_16_sse2(uint16_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh,
+                                     int bd);
 #define vpx_highbd_lpf_vertical_16 vpx_highbd_lpf_vertical_16_sse2
 
-void vpx_highbd_lpf_vertical_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_16_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_dual_c(uint16_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh,
+                                       int bd);
+void vpx_highbd_lpf_vertical_16_dual_sse2(uint16_t* s,
+                                          int pitch,
+                                          const uint8_t* blimit,
+                                          const uint8_t* limit,
+                                          const uint8_t* thresh,
+                                          int bd);
 #define vpx_highbd_lpf_vertical_16_dual vpx_highbd_lpf_vertical_16_dual_sse2
 
-void vpx_highbd_lpf_vertical_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_4_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_4_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
+void vpx_highbd_lpf_vertical_4_sse2(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
 #define vpx_highbd_lpf_vertical_4 vpx_highbd_lpf_vertical_4_sse2
 
-void vpx_highbd_lpf_vertical_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_vertical_4_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_4_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
+void vpx_highbd_lpf_vertical_4_dual_sse2(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit0,
+                                         const uint8_t* limit0,
+                                         const uint8_t* thresh0,
+                                         const uint8_t* blimit1,
+                                         const uint8_t* limit1,
+                                         const uint8_t* thresh1,
+                                         int bd);
 #define vpx_highbd_lpf_vertical_4_dual vpx_highbd_lpf_vertical_4_dual_sse2
 
-void vpx_highbd_lpf_vertical_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_8_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_8_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
+void vpx_highbd_lpf_vertical_8_sse2(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
 #define vpx_highbd_lpf_vertical_8 vpx_highbd_lpf_vertical_8_sse2
 
-void vpx_highbd_lpf_vertical_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_vertical_8_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_8_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
+void vpx_highbd_lpf_vertical_8_dual_sse2(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit0,
+                                         const uint8_t* limit0,
+                                         const uint8_t* thresh0,
+                                         const uint8_t* blimit1,
+                                         const uint8_t* limit1,
+                                         const uint8_t* thresh1,
+                                         int bd);
 #define vpx_highbd_lpf_vertical_8_dual vpx_highbd_lpf_vertical_8_dual_sse2
 
-void vpx_highbd_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_highbd_minmax_8x8_c(const uint8_t* s,
+                             int p,
+                             const uint8_t* d,
+                             int dp,
+                             int* min,
+                             int* max);
 #define vpx_highbd_minmax_8x8 vpx_highbd_minmax_8x8_c
 
-void vpx_highbd_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_highbd_quantize_b_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* zbin_ptr,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             const int16_t* quant_shift_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+void vpx_highbd_quantize_b_sse2(const tran_low_t* coeff_ptr,
+                                intptr_t n_coeffs,
+                                int skip_block,
+                                const int16_t* zbin_ptr,
+                                const int16_t* round_ptr,
+                                const int16_t* quant_ptr,
+                                const int16_t* quant_shift_ptr,
+                                tran_low_t* qcoeff_ptr,
+                                tran_low_t* dqcoeff_ptr,
+                                const int16_t* dequant_ptr,
+                                uint16_t* eob_ptr,
+                                const int16_t* scan,
+                                const int16_t* iscan);
 #define vpx_highbd_quantize_b vpx_highbd_quantize_b_sse2
 
-void vpx_highbd_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_highbd_quantize_b_32x32_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
+void vpx_highbd_quantize_b_32x32_sse2(const tran_low_t* coeff_ptr,
+                                      intptr_t n_coeffs,
+                                      int skip_block,
+                                      const int16_t* zbin_ptr,
+                                      const int16_t* round_ptr,
+                                      const int16_t* quant_ptr,
+                                      const int16_t* quant_shift_ptr,
+                                      tran_low_t* qcoeff_ptr,
+                                      tran_low_t* dqcoeff_ptr,
+                                      const int16_t* dequant_ptr,
+                                      uint16_t* eob_ptr,
+                                      const int16_t* scan,
+                                      const int16_t* iscan);
 #define vpx_highbd_quantize_b_32x32 vpx_highbd_quantize_b_32x32_sse2
 
-unsigned int vpx_highbd_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad16x16_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad16x16 vpx_highbd_sad16x16_sse2
 
-unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x16_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad16x16_avg vpx_highbd_sad16x16_avg_sse2
 
-void vpx_highbd_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad16x16x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad16x16x4d vpx_highbd_sad16x16x4d_sse2
 
-unsigned int vpx_highbd_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad16x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad16x32 vpx_highbd_sad16x32_sse2
 
-unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad16x32_avg vpx_highbd_sad16x32_avg_sse2
 
-void vpx_highbd_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad16x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad16x32x4d vpx_highbd_sad16x32x4d_sse2
 
-unsigned int vpx_highbd_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x8_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int vpx_highbd_sad16x8_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
 #define vpx_highbd_sad16x8 vpx_highbd_sad16x8_sse2
 
-unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x8_avg_sse2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         const uint8_t* second_pred);
 #define vpx_highbd_sad16x8_avg vpx_highbd_sad16x8_avg_sse2
 
-void vpx_highbd_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x8x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void vpx_highbd_sad16x8x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
 #define vpx_highbd_sad16x8x4d vpx_highbd_sad16x8x4d_sse2
 
-unsigned int vpx_highbd_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x16_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad32x16 vpx_highbd_sad32x16_sse2
 
-unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x16_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad32x16_avg vpx_highbd_sad32x16_avg_sse2
 
-void vpx_highbd_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x16x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad32x16x4d vpx_highbd_sad32x16x4d_sse2
 
-unsigned int vpx_highbd_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad32x32 vpx_highbd_sad32x32_sse2
 
-unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad32x32_avg vpx_highbd_sad32x32_avg_sse2
 
-void vpx_highbd_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad32x32x4d vpx_highbd_sad32x32x4d_sse2
 
-unsigned int vpx_highbd_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad32x64 vpx_highbd_sad32x64_sse2
 
-unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x64_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad32x64_avg vpx_highbd_sad32x64_avg_sse2
 
-void vpx_highbd_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad32x64x4d vpx_highbd_sad32x64x4d_sse2
 
-unsigned int vpx_highbd_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x4 vpx_highbd_sad4x4_c
 
-unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x4_avg vpx_highbd_sad4x4_avg_c
 
-void vpx_highbd_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad4x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad4x4x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
 #define vpx_highbd_sad4x4x4d vpx_highbd_sad4x4x4d_sse2
 
-unsigned int vpx_highbd_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x8 vpx_highbd_sad4x8_c
 
-unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x8_avg vpx_highbd_sad4x8_avg_c
 
-void vpx_highbd_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad4x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad4x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
 #define vpx_highbd_sad4x8x4d vpx_highbd_sad4x8x4d_sse2
 
-unsigned int vpx_highbd_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad64x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad64x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad64x32 vpx_highbd_sad64x32_sse2
 
-unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad64x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad64x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad64x32_avg vpx_highbd_sad64x32_avg_sse2
 
-void vpx_highbd_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad64x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad64x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad64x32x4d vpx_highbd_sad64x32x4d_sse2
 
-unsigned int vpx_highbd_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad64x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad64x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad64x64 vpx_highbd_sad64x64_sse2
 
-unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad64x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad64x64_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad64x64_avg vpx_highbd_sad64x64_avg_sse2
 
-void vpx_highbd_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad64x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad64x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad64x64x4d vpx_highbd_sad64x64x4d_sse2
 
-unsigned int vpx_highbd_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int vpx_highbd_sad8x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
 #define vpx_highbd_sad8x16 vpx_highbd_sad8x16_sse2
 
-unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x16_avg_sse2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         const uint8_t* second_pred);
 #define vpx_highbd_sad8x16_avg vpx_highbd_sad8x16_avg_sse2
 
-void vpx_highbd_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void vpx_highbd_sad8x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
 #define vpx_highbd_sad8x16x4d vpx_highbd_sad8x16x4d_sse2
 
-unsigned int vpx_highbd_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int vpx_highbd_sad8x4_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
 #define vpx_highbd_sad8x4 vpx_highbd_sad8x4_sse2
 
-unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x4_avg_sse2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        const uint8_t* second_pred);
 #define vpx_highbd_sad8x4_avg vpx_highbd_sad8x4_avg_sse2
 
-void vpx_highbd_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad8x4x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
 #define vpx_highbd_sad8x4x4d vpx_highbd_sad8x4x4d_sse2
 
-unsigned int vpx_highbd_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int vpx_highbd_sad8x8_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
 #define vpx_highbd_sad8x8 vpx_highbd_sad8x8_sse2
 
-unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x8_avg_sse2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        const uint8_t* second_pred);
 #define vpx_highbd_sad8x8_avg vpx_highbd_sad8x8_avg_sse2
 
-void vpx_highbd_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad8x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
 #define vpx_highbd_sad8x8x4d vpx_highbd_sad8x8x4d_sse2
 
-void vpx_highbd_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride, int bd);
+void vpx_highbd_subtract_block_c(int rows,
+                                 int cols,
+                                 int16_t* diff_ptr,
+                                 ptrdiff_t diff_stride,
+                                 const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 const uint8_t* pred_ptr,
+                                 ptrdiff_t pred_stride,
+                                 int bd);
 #define vpx_highbd_subtract_block vpx_highbd_subtract_block_c
 
-void vpx_highbd_tm_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_tm_predictor_16x16_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_tm_predictor_16x16 vpx_highbd_tm_predictor_16x16_sse2
 
-void vpx_highbd_tm_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_tm_predictor_32x32_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_tm_predictor_32x32 vpx_highbd_tm_predictor_32x32_sse2
 
-void vpx_highbd_tm_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_tm_predictor_4x4_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_tm_predictor_4x4 vpx_highbd_tm_predictor_4x4_sse2
 
-void vpx_highbd_tm_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_tm_predictor_8x8_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_tm_predictor_8x8 vpx_highbd_tm_predictor_8x8_sse2
 
-void vpx_highbd_v_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
+void vpx_highbd_v_predictor_16x16_sse2(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_v_predictor_16x16 vpx_highbd_v_predictor_16x16_sse2
 
-void vpx_highbd_v_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
+void vpx_highbd_v_predictor_32x32_sse2(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_v_predictor_32x32 vpx_highbd_v_predictor_32x32_sse2
 
-void vpx_highbd_v_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
+void vpx_highbd_v_predictor_4x4_sse2(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_v_predictor_4x4 vpx_highbd_v_predictor_4x4_sse2
 
-void vpx_highbd_v_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
+void vpx_highbd_v_predictor_8x8_sse2(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_v_predictor_8x8 vpx_highbd_v_predictor_8x8_sse2
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_10_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_10_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct16x16_10_add vpx_idct16x16_10_add_sse2
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_1_add_sse2(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct16x16_1_add vpx_idct16x16_1_add_sse2
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_256_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct16x16_256_add_sse2(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
 #define vpx_idct16x16_256_add vpx_idct16x16_256_add_sse2
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_38_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_38_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct16x16_38_add vpx_idct16x16_38_add_sse2
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+void vpx_idct32x32_1024_add_sse2(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
 #define vpx_idct32x32_1024_add vpx_idct32x32_1024_add_sse2
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_135_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_135_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct32x32_1024_add_sse2(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+void vpx_idct32x32_135_add_ssse3(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+RTCD_EXTERN void (*vpx_idct32x32_135_add)(const tran_low_t* input,
+                                          uint8_t* dest,
+                                          int stride);
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_1_add_sse2(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct32x32_1_add vpx_idct32x32_1_add_sse2
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_34_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_34_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+void vpx_idct32x32_34_add_ssse3(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
+RTCD_EXTERN void (*vpx_idct32x32_34_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_16_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct4x4_16_add vpx_idct4x4_16_add_sse2
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_1_add_sse2(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_1_add vpx_idct4x4_1_add_sse2
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_12_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_12_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct8x8_12_add_ssse3(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+RTCD_EXTERN void (*vpx_idct8x8_12_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_1_add_sse2(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_1_add vpx_idct8x8_1_add_sse2
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_64_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_64_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct8x8_64_add vpx_idct8x8_64_add_sse2
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
-int16_t vpx_int_pro_col_sse2(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
+int16_t vpx_int_pro_col_sse2(const uint8_t* ref, const int width);
 #define vpx_int_pro_col vpx_int_pro_col_sse2
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-void vpx_int_pro_row_sse2(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
+void vpx_int_pro_row_sse2(int16_t* hbuf,
+                          const uint8_t* ref,
+                          const int ref_stride,
+                          const int height);
 #define vpx_int_pro_row vpx_int_pro_row_sse2
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_iwht4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_iwht4x4_16_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_iwht4x4_16_add vpx_iwht4x4_16_add_sse2
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_avx2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_16)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+void vpx_lpf_horizontal_16_sse2(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_horizontal_16_avx2(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_16)(uint8_t* s,
+                                          int pitch,
+                                          const uint8_t* blimit,
+                                          const uint8_t* limit,
+                                          const uint8_t* thresh);
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_avx2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_16_dual)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_sse2(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_avx2(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_16_dual)(uint8_t* s,
+                                               int pitch,
+                                               const uint8_t* blimit,
+                                               const uint8_t* limit,
+                                               const uint8_t* thresh);
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_4_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_4_sse2(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
 #define vpx_lpf_horizontal_4 vpx_lpf_horizontal_4_sse2
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_4_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_4_dual_sse2(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
 #define vpx_lpf_horizontal_4_dual vpx_lpf_horizontal_4_dual_sse2
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_8_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_8_sse2(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
 #define vpx_lpf_horizontal_8 vpx_lpf_horizontal_8_sse2
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_8_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_8_dual_sse2(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
 #define vpx_lpf_horizontal_8_dual vpx_lpf_horizontal_8_dual_sse2
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
+void vpx_lpf_vertical_16_sse2(uint8_t* s,
+                              int pitch,
+                              const uint8_t* blimit,
+                              const uint8_t* limit,
+                              const uint8_t* thresh);
 #define vpx_lpf_vertical_16 vpx_lpf_vertical_16_sse2
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_vertical_16_dual_sse2(uint8_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh);
 #define vpx_lpf_vertical_16_dual vpx_lpf_vertical_16_dual_sse2
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_4_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_4_sse2(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_vertical_4 vpx_lpf_vertical_4_sse2
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_4_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_4_dual_sse2(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
 #define vpx_lpf_vertical_4_dual vpx_lpf_vertical_4_dual_sse2
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_8_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_8_sse2(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_vertical_8 vpx_lpf_vertical_8_sse2
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_8_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_8_dual_sse2(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
 #define vpx_lpf_vertical_8_dual vpx_lpf_vertical_8_dual_sse2
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_across_ip_sse2(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
+void vpx_mbpost_proc_across_ip_sse2(unsigned char* dst,
+                                    int pitch,
+                                    int rows,
+                                    int cols,
+                                    int flimit);
 #define vpx_mbpost_proc_across_ip vpx_mbpost_proc_across_ip_sse2
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_down_sse2(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
+void vpx_mbpost_proc_down_sse2(unsigned char* dst,
+                               int pitch,
+                               int rows,
+                               int cols,
+                               int flimit);
 #define vpx_mbpost_proc_down vpx_mbpost_proc_down_sse2
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-void vpx_minmax_8x8_sse2(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
+void vpx_minmax_8x8_sse2(const uint8_t* s,
+                         int p,
+                         const uint8_t* d,
+                         int dp,
+                         int* min,
+                         int* max);
 #define vpx_minmax_8x8 vpx_minmax_8x8_sse2
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_avx2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
+unsigned int vpx_mse16x16_sse2(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
+unsigned int vpx_mse16x16_avx2(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse16x16)(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
+unsigned int vpx_mse16x8_sse2(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int recon_stride,
+                              unsigned int* sse);
 #define vpx_mse16x8 vpx_mse16x8_sse2
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse8x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
+unsigned int vpx_mse8x16_sse2(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int recon_stride,
+                              unsigned int* sse);
 #define vpx_mse8x16 vpx_mse8x16_sse2
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
+unsigned int vpx_mse8x8_sse2(const uint8_t* src_ptr,
+                             int source_stride,
+                             const uint8_t* ref_ptr,
+                             int recon_stride,
+                             unsigned int* sse);
 #define vpx_mse8x8 vpx_mse8x8_sse2
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
-void vpx_plane_add_noise_sse2(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
+void vpx_plane_add_noise_sse2(uint8_t* start,
+                              const int8_t* noise,
+                              int blackclamp,
+                              int whiteclamp,
+                              int width,
+                              int height,
+                              int pitch);
 #define vpx_plane_add_noise vpx_plane_add_noise_sse2
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-void vpx_post_proc_down_and_across_mb_row_sse2(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-#define vpx_post_proc_down_and_across_mb_row vpx_post_proc_down_and_across_mb_row_sse2
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+void vpx_post_proc_down_and_across_mb_row_sse2(unsigned char* src,
+                                               unsigned char* dst,
+                                               int src_pitch,
+                                               int dst_pitch,
+                                               int cols,
+                                               unsigned char* flimits,
+                                               int size);
+#define vpx_post_proc_down_and_across_mb_row \
+  vpx_post_proc_down_and_across_mb_row_sse2
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_ssse3(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_avx(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_quantize_b)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
+void vpx_quantize_b_sse2(const tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* zbin_ptr,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         const int16_t* quant_shift_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+void vpx_quantize_b_ssse3(const tran_low_t* coeff_ptr,
+                          intptr_t n_coeffs,
+                          int skip_block,
+                          const int16_t* zbin_ptr,
+                          const int16_t* round_ptr,
+                          const int16_t* quant_ptr,
+                          const int16_t* quant_shift_ptr,
+                          tran_low_t* qcoeff_ptr,
+                          tran_low_t* dqcoeff_ptr,
+                          const int16_t* dequant_ptr,
+                          uint16_t* eob_ptr,
+                          const int16_t* scan,
+                          const int16_t* iscan);
+void vpx_quantize_b_avx(const tran_low_t* coeff_ptr,
+                        intptr_t n_coeffs,
+                        int skip_block,
+                        const int16_t* zbin_ptr,
+                        const int16_t* round_ptr,
+                        const int16_t* quant_ptr,
+                        const int16_t* quant_shift_ptr,
+                        tran_low_t* qcoeff_ptr,
+                        tran_low_t* dqcoeff_ptr,
+                        const int16_t* dequant_ptr,
+                        uint16_t* eob_ptr,
+                        const int16_t* scan,
+                        const int16_t* iscan);
+RTCD_EXTERN void (*vpx_quantize_b)(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_32x32_ssse3(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_32x32_avx(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_quantize_b_32x32)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
+void vpx_quantize_b_32x32_ssse3(const tran_low_t* coeff_ptr,
+                                intptr_t n_coeffs,
+                                int skip_block,
+                                const int16_t* zbin_ptr,
+                                const int16_t* round_ptr,
+                                const int16_t* quant_ptr,
+                                const int16_t* quant_shift_ptr,
+                                tran_low_t* qcoeff_ptr,
+                                tran_low_t* dqcoeff_ptr,
+                                const int16_t* dequant_ptr,
+                                uint16_t* eob_ptr,
+                                const int16_t* scan,
+                                const int16_t* iscan);
+void vpx_quantize_b_32x32_avx(const tran_low_t* coeff_ptr,
+                              intptr_t n_coeffs,
+                              int skip_block,
+                              const int16_t* zbin_ptr,
+                              const int16_t* round_ptr,
+                              const int16_t* quant_ptr,
+                              const int16_t* quant_shift_ptr,
+                              tran_low_t* qcoeff_ptr,
+                              tran_low_t* dqcoeff_ptr,
+                              const int16_t* dequant_ptr,
+                              uint16_t* eob_ptr,
+                              const int16_t* scan,
+                              const int16_t* iscan);
+RTCD_EXTERN void (*vpx_quantize_b_32x32)(const tran_low_t* coeff_ptr,
+                                         intptr_t n_coeffs,
+                                         int skip_block,
+                                         const int16_t* zbin_ptr,
+                                         const int16_t* round_ptr,
+                                         const int16_t* quant_ptr,
+                                         const int16_t* quant_shift_ptr,
+                                         tran_low_t* qcoeff_ptr,
+                                         tran_low_t* dqcoeff_ptr,
+                                         const int16_t* dequant_ptr,
+                                         uint16_t* eob_ptr,
+                                         const int16_t* scan,
+                                         const int16_t* iscan);
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x16_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad16x16 vpx_sad16x16_sse2
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x16_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad16x16_avg vpx_sad16x16_avg_sse2
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x3_ssse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x16x3_sse3(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+void vpx_sad16x16x3_ssse3(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x3)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x16x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad16x16x4d vpx_sad16x16x4d_sse2
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x16x8_sse4_1(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride,
+                           uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x8)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad16x32 vpx_sad16x32_sse2
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad16x32_avg vpx_sad16x32_avg_sse2
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad16x32x4d vpx_sad16x32x4d_sse2
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad16x8_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
 #define vpx_sad16x8 vpx_sad16x8_sse2
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad16x8_avg_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
 #define vpx_sad16x8_avg vpx_sad16x8_avg_sse2
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x3_ssse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad16x8x3_sse3(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        uint32_t* sad_array);
+void vpx_sad16x8x3_ssse3(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x3)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x8x4d_sse2(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
 #define vpx_sad16x8x4d vpx_sad16x8x4d_sse2
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad16x8x8_sse4_1(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x8)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x16_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x16_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x16)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x16_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x16x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x16x4d vpx_sad32x16x4d_sse2
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x32_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+void vpx_sad32x32x4d_avx2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x64_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x64_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x64)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x64_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x64x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x64x4d vpx_sad32x64x4d_sse2
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x4_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad4x4 vpx_sad4x4_sse2
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x4_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad4x4_avg vpx_sad4x4_avg_sse2
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad4x4x3_sse3(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x3)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x4x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad4x4x4d vpx_sad4x4x4d_sse2
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad4x4x8_sse4_1(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x8)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x8_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad4x8 vpx_sad4x8_sse2
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x8_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad4x8_avg vpx_sad4x8_avg_sse2
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x8x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad4x8x4d vpx_sad4x8x4d_sse2
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad64x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad64x32_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad64x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad64x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad64x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad64x32x4d vpx_sad64x32x4d_sse2
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad64x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x64_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad64x64_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad64x64)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad64x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad64x64_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad64x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x64x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+void vpx_sad64x64x4d_avx2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad64x64x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad8x16_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
 #define vpx_sad8x16 vpx_sad8x16_sse2
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad8x16_avg_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
 #define vpx_sad8x16_avg vpx_sad8x16_avg_sse2
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x16x3_sse3(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x3)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad8x16x4d_sse2(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
 #define vpx_sad8x16x4d vpx_sad8x16x4d_sse2
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x16x8_sse4_1(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x8)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x4_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad8x4 vpx_sad8x4_sse2
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x4_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad8x4_avg vpx_sad8x4_avg_sse2
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x4x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad8x4x4d vpx_sad8x4x4d_sse2
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x8_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad8x8 vpx_sad8x8_sse2
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x8_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad8x8_avg vpx_sad8x8_avg_sse2
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad8x8x3_sse3(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x3)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x8x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad8x8x4d vpx_sad8x8x4d_sse2
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad8x8x8_sse4_1(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x8)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-int vpx_satd_c(const tran_low_t *coeff, int length);
-int vpx_satd_sse2(const tran_low_t *coeff, int length);
+int vpx_satd_c(const tran_low_t* coeff, int length);
+int vpx_satd_sse2(const tran_low_t* coeff, int length);
 #define vpx_satd vpx_satd_sse2
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_scaled_2d_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_scaled_2d)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_scaled_2d_ssse3(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+RTCD_EXTERN void (*vpx_scaled_2d)(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_ssse3(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_avx2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_avx2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_ssse3(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x16)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_ssse3(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x8)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x16)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_avx2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x64)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x4)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x8)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_avx2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x64)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_ssse3(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x16)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x4)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x8)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-void vpx_subtract_block_sse2(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
+void vpx_subtract_block_sse2(int rows,
+                             int cols,
+                             int16_t* diff_ptr,
+                             ptrdiff_t diff_stride,
+                             const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             const uint8_t* pred_ptr,
+                             ptrdiff_t pred_stride);
 #define vpx_subtract_block vpx_subtract_block_sse2
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
-uint64_t vpx_sum_squares_2d_i16_sse2(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_sse2(const int16_t* src, int stride, int size);
 #define vpx_sum_squares_2d_i16 vpx_sum_squares_2d_i16_sse2
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_16x16_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_tm_predictor_16x16 vpx_tm_predictor_16x16_sse2
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_32x32_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_tm_predictor_32x32 vpx_tm_predictor_32x32_sse2
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_4x4_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_tm_predictor_4x4 vpx_tm_predictor_4x4_sse2
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_8x8_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_tm_predictor_8x8 vpx_tm_predictor_8x8_sse2
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_16x16_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_v_predictor_16x16 vpx_v_predictor_16x16_sse2
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_32x32_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_v_predictor_32x32 vpx_v_predictor_32x32_sse2
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_4x4_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_v_predictor_4x4 vpx_v_predictor_4x4_sse2
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_8x8_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_v_predictor_8x8 vpx_v_predictor_8x8_sse2
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x16_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance16x16_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x16)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance16x32 vpx_variance16x32_sse2
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance16x8_sse2(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
 #define vpx_variance16x8 vpx_variance16x8_sse2
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x16_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance32x16_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x16)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance32x32_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x64_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x64 vpx_variance32x64_sse2
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x4_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance4x4 vpx_variance4x4_sse2
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x8_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance4x8 vpx_variance4x8_sse2
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance64x32_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance64x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x64_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance64x64_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance64x64)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance8x16_sse2(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
 #define vpx_variance8x16 vpx_variance8x16_sse2
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x4_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance8x4 vpx_variance8x4_sse2
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x8_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance8x8 vpx_variance8x8_sse2
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
-int vpx_vector_var_sse2(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
+int vpx_vector_var_sse2(const int16_t* ref, const int16_t* src, const int bwl);
 #define vpx_vector_var vpx_vector_var_sse2
 
 void vpx_dsp_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vpx_convolve8 = vpx_convolve8_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8 = vpx_convolve8_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8 = vpx_convolve8_avx2;
-    vpx_convolve8_avg = vpx_convolve8_avg_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg = vpx_convolve8_avg_ssse3;
-    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_ssse3;
-    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_ssse3;
-    vpx_convolve8_horiz = vpx_convolve8_horiz_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_horiz = vpx_convolve8_horiz_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8_horiz = vpx_convolve8_horiz_avx2;
-    vpx_convolve8_vert = vpx_convolve8_vert_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_vert = vpx_convolve8_vert_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8_vert = vpx_convolve8_vert_avx2;
-    vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_ssse3;
-    vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_ssse3;
-    vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_ssse3;
-    vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_ssse3;
-    vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_ssse3;
-    vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_ssse3;
-    vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_ssse3;
-    vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_ssse3;
-    vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_ssse3;
-    vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_ssse3;
-    vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_ssse3;
-    vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_ssse3;
-    vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_ssse3;
-    vpx_get16x16var = vpx_get16x16var_sse2;
-    if (flags & HAS_AVX2) vpx_get16x16var = vpx_get16x16var_avx2;
-    vpx_hadamard_8x8 = vpx_hadamard_8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_hadamard_8x8 = vpx_hadamard_8x8_ssse3;
-    vpx_highbd_convolve8 = vpx_highbd_convolve8_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8 = vpx_highbd_convolve8_avx2;
-    vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_avx2;
-    vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_avx2;
-    vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_avx2;
-    vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_avx2;
-    vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_avx2;
-    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_avx2;
-    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_avx2;
-    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse4_1;
-    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse4_1;
-    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse4_1;
-    vpx_idct32x32_135_add = vpx_idct32x32_1024_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct32x32_135_add = vpx_idct32x32_135_add_ssse3;
-    vpx_idct32x32_34_add = vpx_idct32x32_34_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct32x32_34_add = vpx_idct32x32_34_add_ssse3;
-    vpx_idct8x8_12_add = vpx_idct8x8_12_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct8x8_12_add = vpx_idct8x8_12_add_ssse3;
-    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_sse2;
-    if (flags & HAS_AVX2) vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_avx2;
-    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_sse2;
-    if (flags & HAS_AVX2) vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_avx2;
-    vpx_mse16x16 = vpx_mse16x16_sse2;
-    if (flags & HAS_AVX2) vpx_mse16x16 = vpx_mse16x16_avx2;
-    vpx_quantize_b = vpx_quantize_b_sse2;
-    if (flags & HAS_SSSE3) vpx_quantize_b = vpx_quantize_b_ssse3;
-    if (flags & HAS_AVX) vpx_quantize_b = vpx_quantize_b_avx;
-    vpx_quantize_b_32x32 = vpx_quantize_b_32x32_c;
-    if (flags & HAS_SSSE3) vpx_quantize_b_32x32 = vpx_quantize_b_32x32_ssse3;
-    if (flags & HAS_AVX) vpx_quantize_b_32x32 = vpx_quantize_b_32x32_avx;
-    vpx_sad16x16x3 = vpx_sad16x16x3_c;
-    if (flags & HAS_SSE3) vpx_sad16x16x3 = vpx_sad16x16x3_sse3;
-    if (flags & HAS_SSSE3) vpx_sad16x16x3 = vpx_sad16x16x3_ssse3;
-    vpx_sad16x16x8 = vpx_sad16x16x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad16x16x8 = vpx_sad16x16x8_sse4_1;
-    vpx_sad16x8x3 = vpx_sad16x8x3_c;
-    if (flags & HAS_SSE3) vpx_sad16x8x3 = vpx_sad16x8x3_sse3;
-    if (flags & HAS_SSSE3) vpx_sad16x8x3 = vpx_sad16x8x3_ssse3;
-    vpx_sad16x8x8 = vpx_sad16x8x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad16x8x8 = vpx_sad16x8x8_sse4_1;
-    vpx_sad32x16 = vpx_sad32x16_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x16 = vpx_sad32x16_avx2;
-    vpx_sad32x16_avg = vpx_sad32x16_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x16_avg = vpx_sad32x16_avg_avx2;
-    vpx_sad32x32 = vpx_sad32x32_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32 = vpx_sad32x32_avx2;
-    vpx_sad32x32_avg = vpx_sad32x32_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32_avg = vpx_sad32x32_avg_avx2;
-    vpx_sad32x32x4d = vpx_sad32x32x4d_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32x4d = vpx_sad32x32x4d_avx2;
-    vpx_sad32x64 = vpx_sad32x64_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x64 = vpx_sad32x64_avx2;
-    vpx_sad32x64_avg = vpx_sad32x64_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x64_avg = vpx_sad32x64_avg_avx2;
-    vpx_sad4x4x3 = vpx_sad4x4x3_c;
-    if (flags & HAS_SSE3) vpx_sad4x4x3 = vpx_sad4x4x3_sse3;
-    vpx_sad4x4x8 = vpx_sad4x4x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad4x4x8 = vpx_sad4x4x8_sse4_1;
-    vpx_sad64x32 = vpx_sad64x32_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x32 = vpx_sad64x32_avx2;
-    vpx_sad64x32_avg = vpx_sad64x32_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x32_avg = vpx_sad64x32_avg_avx2;
-    vpx_sad64x64 = vpx_sad64x64_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64 = vpx_sad64x64_avx2;
-    vpx_sad64x64_avg = vpx_sad64x64_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64_avg = vpx_sad64x64_avg_avx2;
-    vpx_sad64x64x4d = vpx_sad64x64x4d_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64x4d = vpx_sad64x64x4d_avx2;
-    vpx_sad8x16x3 = vpx_sad8x16x3_c;
-    if (flags & HAS_SSE3) vpx_sad8x16x3 = vpx_sad8x16x3_sse3;
-    vpx_sad8x16x8 = vpx_sad8x16x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad8x16x8 = vpx_sad8x16x8_sse4_1;
-    vpx_sad8x8x3 = vpx_sad8x8x3_c;
-    if (flags & HAS_SSE3) vpx_sad8x8x3 = vpx_sad8x8x3_sse3;
-    vpx_sad8x8x8 = vpx_sad8x8x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad8x8x8 = vpx_sad8x8x8_sse4_1;
-    vpx_scaled_2d = vpx_scaled_2d_c;
-    if (flags & HAS_SSSE3) vpx_scaled_2d = vpx_scaled_2d_ssse3;
-    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_ssse3;
-    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_ssse3;
-    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_ssse3;
-    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_ssse3;
-    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_avx2;
-    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_ssse3;
-    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_ssse3;
-    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_ssse3;
-    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_ssse3;
-    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_avx2;
-    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_ssse3;
-    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_ssse3;
-    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_ssse3;
-    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_ssse3;
-    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_ssse3;
-    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_ssse3;
-    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_ssse3;
-    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_avx2;
-    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_ssse3;
-    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_ssse3;
-    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_ssse3;
-    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_ssse3;
-    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_avx2;
-    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_ssse3;
-    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_ssse3;
-    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_ssse3;
-    vpx_variance16x16 = vpx_variance16x16_sse2;
-    if (flags & HAS_AVX2) vpx_variance16x16 = vpx_variance16x16_avx2;
-    vpx_variance32x16 = vpx_variance32x16_sse2;
-    if (flags & HAS_AVX2) vpx_variance32x16 = vpx_variance32x16_avx2;
-    vpx_variance32x32 = vpx_variance32x32_sse2;
-    if (flags & HAS_AVX2) vpx_variance32x32 = vpx_variance32x32_avx2;
-    vpx_variance64x32 = vpx_variance64x32_sse2;
-    if (flags & HAS_AVX2) vpx_variance64x32 = vpx_variance64x32_avx2;
-    vpx_variance64x64 = vpx_variance64x64_sse2;
-    if (flags & HAS_AVX2) vpx_variance64x64 = vpx_variance64x64_avx2;
+  vpx_convolve8 = vpx_convolve8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8 = vpx_convolve8_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8 = vpx_convolve8_avx2;
+  vpx_convolve8_avg = vpx_convolve8_avg_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg = vpx_convolve8_avg_ssse3;
+  vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_ssse3;
+  vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_ssse3;
+  vpx_convolve8_horiz = vpx_convolve8_horiz_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_avx2;
+  vpx_convolve8_vert = vpx_convolve8_vert_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_vert = vpx_convolve8_vert_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8_vert = vpx_convolve8_vert_avx2;
+  vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_ssse3;
+  vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_ssse3;
+  vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_ssse3;
+  vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_ssse3;
+  vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_ssse3;
+  vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_ssse3;
+  vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_ssse3;
+  vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_ssse3;
+  vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_ssse3;
+  vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_ssse3;
+  vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_ssse3;
+  vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_ssse3;
+  vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_ssse3;
+  vpx_get16x16var = vpx_get16x16var_sse2;
+  if (flags & HAS_AVX2)
+    vpx_get16x16var = vpx_get16x16var_avx2;
+  vpx_hadamard_8x8 = vpx_hadamard_8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_hadamard_8x8 = vpx_hadamard_8x8_ssse3;
+  vpx_highbd_convolve8 = vpx_highbd_convolve8_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8 = vpx_highbd_convolve8_avx2;
+  vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_avx2;
+  vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_avx2;
+  vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_avx2;
+  vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_avx2;
+  vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_avx2;
+  vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_avx2;
+  vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_avx2;
+  vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse4_1;
+  vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse4_1;
+  vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse4_1;
+  vpx_idct32x32_135_add = vpx_idct32x32_1024_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct32x32_135_add = vpx_idct32x32_135_add_ssse3;
+  vpx_idct32x32_34_add = vpx_idct32x32_34_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct32x32_34_add = vpx_idct32x32_34_add_ssse3;
+  vpx_idct8x8_12_add = vpx_idct8x8_12_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct8x8_12_add = vpx_idct8x8_12_add_ssse3;
+  vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_avx2;
+  vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_sse2;
+  if (flags & HAS_AVX2)
+    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_avx2;
+  vpx_mse16x16 = vpx_mse16x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_mse16x16 = vpx_mse16x16_avx2;
+  vpx_quantize_b = vpx_quantize_b_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_quantize_b = vpx_quantize_b_ssse3;
+  if (flags & HAS_AVX)
+    vpx_quantize_b = vpx_quantize_b_avx;
+  vpx_quantize_b_32x32 = vpx_quantize_b_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_quantize_b_32x32 = vpx_quantize_b_32x32_ssse3;
+  if (flags & HAS_AVX)
+    vpx_quantize_b_32x32 = vpx_quantize_b_32x32_avx;
+  vpx_sad16x16x3 = vpx_sad16x16x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad16x16x3 = vpx_sad16x16x3_sse3;
+  if (flags & HAS_SSSE3)
+    vpx_sad16x16x3 = vpx_sad16x16x3_ssse3;
+  vpx_sad16x16x8 = vpx_sad16x16x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad16x16x8 = vpx_sad16x16x8_sse4_1;
+  vpx_sad16x8x3 = vpx_sad16x8x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad16x8x3 = vpx_sad16x8x3_sse3;
+  if (flags & HAS_SSSE3)
+    vpx_sad16x8x3 = vpx_sad16x8x3_ssse3;
+  vpx_sad16x8x8 = vpx_sad16x8x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad16x8x8 = vpx_sad16x8x8_sse4_1;
+  vpx_sad32x16 = vpx_sad32x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x16 = vpx_sad32x16_avx2;
+  vpx_sad32x16_avg = vpx_sad32x16_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x16_avg = vpx_sad32x16_avg_avx2;
+  vpx_sad32x32 = vpx_sad32x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32 = vpx_sad32x32_avx2;
+  vpx_sad32x32_avg = vpx_sad32x32_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32_avg = vpx_sad32x32_avg_avx2;
+  vpx_sad32x32x4d = vpx_sad32x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32x4d = vpx_sad32x32x4d_avx2;
+  vpx_sad32x64 = vpx_sad32x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x64 = vpx_sad32x64_avx2;
+  vpx_sad32x64_avg = vpx_sad32x64_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x64_avg = vpx_sad32x64_avg_avx2;
+  vpx_sad4x4x3 = vpx_sad4x4x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad4x4x3 = vpx_sad4x4x3_sse3;
+  vpx_sad4x4x8 = vpx_sad4x4x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad4x4x8 = vpx_sad4x4x8_sse4_1;
+  vpx_sad64x32 = vpx_sad64x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x32 = vpx_sad64x32_avx2;
+  vpx_sad64x32_avg = vpx_sad64x32_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x32_avg = vpx_sad64x32_avg_avx2;
+  vpx_sad64x64 = vpx_sad64x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64 = vpx_sad64x64_avx2;
+  vpx_sad64x64_avg = vpx_sad64x64_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64_avg = vpx_sad64x64_avg_avx2;
+  vpx_sad64x64x4d = vpx_sad64x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64x4d = vpx_sad64x64x4d_avx2;
+  vpx_sad8x16x3 = vpx_sad8x16x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad8x16x3 = vpx_sad8x16x3_sse3;
+  vpx_sad8x16x8 = vpx_sad8x16x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad8x16x8 = vpx_sad8x16x8_sse4_1;
+  vpx_sad8x8x3 = vpx_sad8x8x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad8x8x3 = vpx_sad8x8x3_sse3;
+  vpx_sad8x8x8 = vpx_sad8x8x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad8x8x8 = vpx_sad8x8x8_sse4_1;
+  vpx_scaled_2d = vpx_scaled_2d_c;
+  if (flags & HAS_SSSE3)
+    vpx_scaled_2d = vpx_scaled_2d_ssse3;
+  vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_ssse3;
+  vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_ssse3;
+  vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_ssse3;
+  vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_ssse3;
+  vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_avx2;
+  vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_ssse3;
+  vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_ssse3;
+  vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_ssse3;
+  vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_ssse3;
+  vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_avx2;
+  vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_ssse3;
+  vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_ssse3;
+  vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_ssse3;
+  vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_ssse3;
+  vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_ssse3;
+  vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_ssse3;
+  vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_ssse3;
+  vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_avx2;
+  vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_ssse3;
+  vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_ssse3;
+  vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_ssse3;
+  vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_ssse3;
+  vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_avx2;
+  vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_ssse3;
+  vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_ssse3;
+  vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_ssse3;
+  vpx_variance16x16 = vpx_variance16x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance16x16 = vpx_variance16x16_avx2;
+  vpx_variance32x16 = vpx_variance32x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance32x16 = vpx_variance32x16_avx2;
+  vpx_variance32x32 = vpx_variance32x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance32x32 = vpx_variance32x32_avx2;
+  vpx_variance64x32 = vpx_variance64x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance64x32 = vpx_variance64x32_avx2;
+  vpx_variance64x64 = vpx_variance64x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance64x64 = vpx_variance64x64_avx2;
 }
 #endif
 

third_party/libvpx/source/config/linux/x64/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/linux/x64/vpx_scale_rtcd.h b/third_party/libvpx/source/config/linux/x64/vpx_scale_rtcd.h
index ada0f6d..0ba352cb 100644
--- a/third_party/libvpx/source/config/linux/x64/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/linux/x64/vpx_scale_rtcd.h
@@ -13,55 +13,81 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/mac/ia32/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/mac/ia32/vp8_rtcd.h b/third_party/libvpx/source/config/mac/ia32/vp8_rtcd.h
index 3addf41..2f3a2d3 100644
--- a/third_party/libvpx/source/config/mac/ia32/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/mac/ia32/vp8_rtcd.h
@@ -26,303 +26,868 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict16x16)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+void vp8_bilinear_predict16x16_sse2(unsigned char* src,
+                                    int src_pitch,
+                                    int xofst,
+                                    int yofst,
+                                    unsigned char* dst,
+                                    int dst_pitch);
+void vp8_bilinear_predict16x16_ssse3(unsigned char* src,
+                                     int src_pitch,
+                                     int xofst,
+                                     int yofst,
+                                     unsigned char* dst,
+                                     int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict16x16)(unsigned char* src,
+                                              int src_pitch,
+                                              int xofst,
+                                              int yofst,
+                                              unsigned char* dst,
+                                              int dst_pitch);
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict4x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict4x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict4x4_mmx(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict4x4)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict8x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x4_mmx(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict8x4)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict8x8)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x8_sse2(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+void vp8_bilinear_predict8x8_ssse3(unsigned char* src,
+                                   int src_pitch,
+                                   int xofst,
+                                   int yofst,
+                                   unsigned char* dst,
+                                   int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict8x8)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
-int vp8_block_error_sse2(short *coeff, short *dqcoeff);
-RTCD_EXTERN int (*vp8_block_error)(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
+int vp8_block_error_sse2(short* coeff, short* dqcoeff);
+RTCD_EXTERN int (*vp8_block_error)(short* coeff, short* dqcoeff);
 
-void vp8_copy32xn_c(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-void vp8_copy32xn_sse2(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-void vp8_copy32xn_sse3(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-RTCD_EXTERN void (*vp8_copy32xn)(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
+void vp8_copy32xn_c(const unsigned char* src_ptr,
+                    int source_stride,
+                    unsigned char* dst_ptr,
+                    int dst_stride,
+                    int n);
+void vp8_copy32xn_sse2(const unsigned char* src_ptr,
+                       int source_stride,
+                       unsigned char* dst_ptr,
+                       int dst_stride,
+                       int n);
+void vp8_copy32xn_sse3(const unsigned char* src_ptr,
+                       int source_stride,
+                       unsigned char* dst_ptr,
+                       int dst_stride,
+                       int n);
+RTCD_EXTERN void (*vp8_copy32xn)(const unsigned char* src_ptr,
+                                 int source_stride,
+                                 unsigned char* dst_ptr,
+                                 int dst_stride,
+                                 int n);
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem16x16_sse2(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_copy_mem16x16)(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+void vp8_copy_mem16x16_sse2(unsigned char* src,
+                            int src_pitch,
+                            unsigned char* dst,
+                            int dst_pitch);
+RTCD_EXTERN void (*vp8_copy_mem16x16)(unsigned char* src,
+                                      int src_pitch,
+                                      unsigned char* dst,
+                                      int dst_pitch);
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x4_mmx(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_copy_mem8x4)(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x4_mmx(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+RTCD_EXTERN void (*vp8_copy_mem8x4)(unsigned char* src,
+                                    int src_pitch,
+                                    unsigned char* dst,
+                                    int dst_pitch);
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x8_mmx(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_copy_mem8x8)(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x8_mmx(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+RTCD_EXTERN void (*vp8_copy_mem8x8)(unsigned char* src,
+                                    int src_pitch,
+                                    unsigned char* dst,
+                                    int dst_pitch);
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-void vp8_dc_only_idct_add_mmx(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-RTCD_EXTERN void (*vp8_dc_only_idct_add)(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_dc_only_idct_add_mmx(short input,
+                              unsigned char* pred,
+                              int pred_stride,
+                              unsigned char* dst,
+                              int dst_stride);
+RTCD_EXTERN void (*vp8_dc_only_idct_add)(short input,
+                                         unsigned char* pred,
+                                         int pred_stride,
+                                         unsigned char* dst,
+                                         int dst_stride);
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_sse2(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-RTCD_EXTERN int (*vp8_denoiser_filter)(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
+int vp8_denoiser_filter_sse2(unsigned char* mc_running_avg_y,
+                             int mc_avg_y_stride,
+                             unsigned char* running_avg_y,
+                             int avg_y_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+RTCD_EXTERN int (*vp8_denoiser_filter)(unsigned char* mc_running_avg_y,
+                                       int mc_avg_y_stride,
+                                       unsigned char* running_avg_y,
+                                       int avg_y_stride,
+                                       unsigned char* sig,
+                                       int sig_stride,
+                                       unsigned int motion_magnitude,
+                                       int increase_denoising);
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_uv_sse2(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-RTCD_EXTERN int (*vp8_denoiser_filter_uv)(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+int vp8_denoiser_filter_uv_sse2(unsigned char* mc_running_avg,
+                                int mc_avg_stride,
+                                unsigned char* running_avg,
+                                int avg_stride,
+                                unsigned char* sig,
+                                int sig_stride,
+                                unsigned int motion_magnitude,
+                                int increase_denoising);
+RTCD_EXTERN int (*vp8_denoiser_filter_uv)(unsigned char* mc_running_avg,
+                                          int mc_avg_stride,
+                                          unsigned char* running_avg,
+                                          int avg_stride,
+                                          unsigned char* sig,
+                                          int sig_stride,
+                                          unsigned int motion_magnitude,
+                                          int increase_denoising);
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
-void vp8_dequant_idct_add_mmx(short *input, short *dq, unsigned char *output, int stride);
-RTCD_EXTERN void (*vp8_dequant_idct_add)(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
+void vp8_dequant_idct_add_mmx(short* input,
+                              short* dq,
+                              unsigned char* output,
+                              int stride);
+RTCD_EXTERN void (*vp8_dequant_idct_add)(short* input,
+                                         short* dq,
+                                         unsigned char* output,
+                                         int stride);
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-void vp8_dequant_idct_add_uv_block_sse2(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-RTCD_EXTERN void (*vp8_dequant_idct_add_uv_block)(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
+void vp8_dequant_idct_add_uv_block_sse2(short* q,
+                                        short* dq,
+                                        unsigned char* dst_u,
+                                        unsigned char* dst_v,
+                                        int stride,
+                                        char* eobs);
+RTCD_EXTERN void (*vp8_dequant_idct_add_uv_block)(short* q,
+                                                  short* dq,
+                                                  unsigned char* dst_u,
+                                                  unsigned char* dst_v,
+                                                  int stride,
+                                                  char* eobs);
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-void vp8_dequant_idct_add_y_block_sse2(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-RTCD_EXTERN void (*vp8_dequant_idct_add_y_block)(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
+void vp8_dequant_idct_add_y_block_sse2(short* q,
+                                       short* dq,
+                                       unsigned char* dst,
+                                       int stride,
+                                       char* eobs);
+RTCD_EXTERN void (*vp8_dequant_idct_add_y_block)(short* q,
+                                                 short* dq,
+                                                 unsigned char* dst,
+                                                 int stride,
+                                                 char* eobs);
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
-void vp8_dequantize_b_mmx(struct blockd*, short *dqc);
-RTCD_EXTERN void (*vp8_dequantize_b)(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
+void vp8_dequantize_b_mmx(struct blockd*, short* dqc);
+RTCD_EXTERN void (*vp8_dequantize_b)(struct blockd*, short* dqc);
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_diamond_search_sadx4(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-RTCD_EXTERN int (*vp8_diamond_search_sad)(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
+int vp8_diamond_search_sadx4(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
+RTCD_EXTERN int (*vp8_diamond_search_sad)(struct macroblock* x,
+                                          struct block* b,
+                                          struct blockd* d,
+                                          union int_mv* ref_mv,
+                                          union int_mv* best_mv,
+                                          int search_param,
+                                          int sad_per_bit,
+                                          int* num00,
+                                          struct variance_vtable* fn_ptr,
+                                          int* mvcost[2],
+                                          union int_mv* center_mv);
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
-void vp8_fast_quantize_b_sse2(struct block *, struct blockd *);
-void vp8_fast_quantize_b_ssse3(struct block *, struct blockd *);
-RTCD_EXTERN void (*vp8_fast_quantize_b)(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
+void vp8_fast_quantize_b_sse2(struct block*, struct blockd*);
+void vp8_fast_quantize_b_ssse3(struct block*, struct blockd*);
+RTCD_EXTERN void (*vp8_fast_quantize_b)(struct block*, struct blockd*);
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-void vp8_filter_by_weight16x16_sse2(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-RTCD_EXTERN void (*vp8_filter_by_weight16x16)(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
+void vp8_filter_by_weight16x16_sse2(unsigned char* src,
+                                    int src_stride,
+                                    unsigned char* dst,
+                                    int dst_stride,
+                                    int src_weight);
+RTCD_EXTERN void (*vp8_filter_by_weight16x16)(unsigned char* src,
+                                              int src_stride,
+                                              unsigned char* dst,
+                                              int dst_stride,
+                                              int src_weight);
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-void vp8_filter_by_weight8x8_sse2(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-RTCD_EXTERN void (*vp8_filter_by_weight8x8)(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
+void vp8_filter_by_weight8x8_sse2(unsigned char* src,
+                                  int src_stride,
+                                  unsigned char* dst,
+                                  int dst_stride,
+                                  int src_weight);
+RTCD_EXTERN void (*vp8_filter_by_weight8x8)(unsigned char* src,
+                                            int src_stride,
+                                            unsigned char* dst,
+                                            int dst_stride,
+                                            int src_weight);
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_full_search_sadx3(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_full_search_sadx8(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-RTCD_EXTERN int (*vp8_full_search_sad)(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+int vp8_full_search_sadx3(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+int vp8_full_search_sadx8(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+RTCD_EXTERN int (*vp8_full_search_sad)(struct macroblock* x,
+                                       struct block* b,
+                                       struct blockd* d,
+                                       union int_mv* ref_mv,
+                                       int sad_per_bit,
+                                       int distance,
+                                       struct variance_vtable* fn_ptr,
+                                       int* mvcost[2],
+                                       union int_mv* center_mv);
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bh_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_bh)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bh_sse2(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_bh)(unsigned char* y,
+                                       unsigned char* u,
+                                       unsigned char* v,
+                                       int ystride,
+                                       int uv_stride,
+                                       struct loop_filter_info* lfi);
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bv_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_bv)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bv_sse2(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_bv)(unsigned char* y,
+                                       unsigned char* u,
+                                       unsigned char* v,
+                                       int ystride,
+                                       int uv_stride,
+                                       struct loop_filter_info* lfi);
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbh_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_mbh)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbh_sse2(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_mbh)(unsigned char* y,
+                                        unsigned char* u,
+                                        unsigned char* v,
+                                        int ystride,
+                                        int uv_stride,
+                                        struct loop_filter_info* lfi);
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbv_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_mbv)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbv_sse2(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_mbv)(unsigned char* y,
+                                        unsigned char* u,
+                                        unsigned char* v,
+                                        int ystride,
+                                        int uv_stride,
+                                        struct loop_filter_info* lfi);
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bhs_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_bh)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bhs_sse2(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_bh)(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bvs_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_bv)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bvs_sse2(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_bv)(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_simple_horizontal_edge_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_mbh)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
+void vp8_loop_filter_simple_horizontal_edge_sse2(unsigned char* y,
+                                                 int ystride,
+                                                 const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_mbh)(unsigned char* y,
+                                               int ystride,
+                                               const unsigned char* blimit);
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_simple_vertical_edge_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_mbv)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
+void vp8_loop_filter_simple_vertical_edge_sse2(unsigned char* y,
+                                               int ystride,
+                                               const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_mbv)(unsigned char* y,
+                                               int ystride,
+                                               const unsigned char* blimit);
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
-int vp8_mbblock_error_sse2(struct macroblock *mb, int dc);
-RTCD_EXTERN int (*vp8_mbblock_error)(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
+int vp8_mbblock_error_sse2(struct macroblock* mb, int dc);
+RTCD_EXTERN int (*vp8_mbblock_error)(struct macroblock* mb, int dc);
 
-int vp8_mbuverror_c(struct macroblock *mb);
-int vp8_mbuverror_sse2(struct macroblock *mb);
-RTCD_EXTERN int (*vp8_mbuverror)(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
+int vp8_mbuverror_sse2(struct macroblock* mb);
+RTCD_EXTERN int (*vp8_mbuverror)(struct macroblock* mb);
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_refining_search_sadx4(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-RTCD_EXTERN int (*vp8_refining_search_sad)(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
+int vp8_refining_search_sadx4(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
+RTCD_EXTERN int (*vp8_refining_search_sad)(struct macroblock* x,
+                                           struct block* b,
+                                           struct blockd* d,
+                                           union int_mv* ref_mv,
+                                           int sad_per_bit,
+                                           int distance,
+                                           struct variance_vtable* fn_ptr,
+                                           int* mvcost[2],
+                                           union int_mv* center_mv);
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
-void vp8_regular_quantize_b_sse2(struct block *, struct blockd *);
-void vp8_regular_quantize_b_sse4_1(struct block *, struct blockd *);
-RTCD_EXTERN void (*vp8_regular_quantize_b)(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
+void vp8_regular_quantize_b_sse2(struct block*, struct blockd*);
+void vp8_regular_quantize_b_sse4_1(struct block*, struct blockd*);
+RTCD_EXTERN void (*vp8_regular_quantize_b)(struct block*, struct blockd*);
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct4x4_sse2(short *input, short *output, int pitch);
-RTCD_EXTERN void (*vp8_short_fdct4x4)(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct4x4_sse2(short* input, short* output, int pitch);
+RTCD_EXTERN void (*vp8_short_fdct4x4)(short* input, short* output, int pitch);
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct8x4_sse2(short *input, short *output, int pitch);
-RTCD_EXTERN void (*vp8_short_fdct8x4)(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct8x4_sse2(short* input, short* output, int pitch);
+RTCD_EXTERN void (*vp8_short_fdct8x4)(short* input, short* output, int pitch);
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-void vp8_short_idct4x4llm_mmx(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-RTCD_EXTERN void (*vp8_short_idct4x4llm)(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_short_idct4x4llm_mmx(short* input,
+                              unsigned char* pred,
+                              int pitch,
+                              unsigned char* dst,
+                              int dst_stride);
+RTCD_EXTERN void (*vp8_short_idct4x4llm)(short* input,
+                                         unsigned char* pred,
+                                         int pitch,
+                                         unsigned char* dst,
+                                         int dst_stride);
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
-void vp8_short_inv_walsh4x4_sse2(short *input, short *output);
-RTCD_EXTERN void (*vp8_short_inv_walsh4x4)(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
+void vp8_short_inv_walsh4x4_sse2(short* input, short* output);
+RTCD_EXTERN void (*vp8_short_inv_walsh4x4)(short* input, short* output);
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
-void vp8_short_walsh4x4_sse2(short *input, short *output, int pitch);
-RTCD_EXTERN void (*vp8_short_walsh4x4)(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
+void vp8_short_walsh4x4_sse2(short* input, short* output, int pitch);
+RTCD_EXTERN void (*vp8_short_walsh4x4)(short* input, short* output, int pitch);
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict16x16)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict16x16_sse2(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+void vp8_sixtap_predict16x16_ssse3(unsigned char* src,
+                                   int src_pitch,
+                                   int xofst,
+                                   int yofst,
+                                   unsigned char* dst,
+                                   int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict16x16)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict4x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict4x4_mmx(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict4x4_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict4x4)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict8x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x4_sse2(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+void vp8_sixtap_predict8x4_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict8x4)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict8x8)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x8_sse2(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+void vp8_sixtap_predict8x8_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict8x8)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
 void vp8_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_c;
-    if (flags & HAS_SSE2) vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_sse2;
-    if (flags & HAS_SSSE3) vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_ssse3;
-    vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_c;
-    if (flags & HAS_MMX) vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_mmx;
-    vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_c;
-    if (flags & HAS_MMX) vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_mmx;
-    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_c;
-    if (flags & HAS_SSE2) vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_sse2;
-    if (flags & HAS_SSSE3) vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_ssse3;
-    vp8_block_error = vp8_block_error_c;
-    if (flags & HAS_SSE2) vp8_block_error = vp8_block_error_sse2;
-    vp8_copy32xn = vp8_copy32xn_c;
-    if (flags & HAS_SSE2) vp8_copy32xn = vp8_copy32xn_sse2;
-    if (flags & HAS_SSE3) vp8_copy32xn = vp8_copy32xn_sse3;
-    vp8_copy_mem16x16 = vp8_copy_mem16x16_c;
-    if (flags & HAS_SSE2) vp8_copy_mem16x16 = vp8_copy_mem16x16_sse2;
-    vp8_copy_mem8x4 = vp8_copy_mem8x4_c;
-    if (flags & HAS_MMX) vp8_copy_mem8x4 = vp8_copy_mem8x4_mmx;
-    vp8_copy_mem8x8 = vp8_copy_mem8x8_c;
-    if (flags & HAS_MMX) vp8_copy_mem8x8 = vp8_copy_mem8x8_mmx;
-    vp8_dc_only_idct_add = vp8_dc_only_idct_add_c;
-    if (flags & HAS_MMX) vp8_dc_only_idct_add = vp8_dc_only_idct_add_mmx;
-    vp8_denoiser_filter = vp8_denoiser_filter_c;
-    if (flags & HAS_SSE2) vp8_denoiser_filter = vp8_denoiser_filter_sse2;
-    vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_c;
-    if (flags & HAS_SSE2) vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_sse2;
-    vp8_dequant_idct_add = vp8_dequant_idct_add_c;
-    if (flags & HAS_MMX) vp8_dequant_idct_add = vp8_dequant_idct_add_mmx;
-    vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_c;
-    if (flags & HAS_SSE2) vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_sse2;
-    vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_c;
-    if (flags & HAS_SSE2) vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_sse2;
-    vp8_dequantize_b = vp8_dequantize_b_c;
-    if (flags & HAS_MMX) vp8_dequantize_b = vp8_dequantize_b_mmx;
-    vp8_diamond_search_sad = vp8_diamond_search_sad_c;
-    if (flags & HAS_SSE2) vp8_diamond_search_sad = vp8_diamond_search_sadx4;
-    vp8_fast_quantize_b = vp8_fast_quantize_b_c;
-    if (flags & HAS_SSE2) vp8_fast_quantize_b = vp8_fast_quantize_b_sse2;
-    if (flags & HAS_SSSE3) vp8_fast_quantize_b = vp8_fast_quantize_b_ssse3;
-    vp8_filter_by_weight16x16 = vp8_filter_by_weight16x16_c;
-    if (flags & HAS_SSE2) vp8_filter_by_weight16x16 = vp8_filter_by_weight16x16_sse2;
-    vp8_filter_by_weight8x8 = vp8_filter_by_weight8x8_c;
-    if (flags & HAS_SSE2) vp8_filter_by_weight8x8 = vp8_filter_by_weight8x8_sse2;
-    vp8_full_search_sad = vp8_full_search_sad_c;
-    if (flags & HAS_SSE3) vp8_full_search_sad = vp8_full_search_sadx3;
-    if (flags & HAS_SSE4_1) vp8_full_search_sad = vp8_full_search_sadx8;
-    vp8_loop_filter_bh = vp8_loop_filter_bh_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_bh = vp8_loop_filter_bh_sse2;
-    vp8_loop_filter_bv = vp8_loop_filter_bv_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_bv = vp8_loop_filter_bv_sse2;
-    vp8_loop_filter_mbh = vp8_loop_filter_mbh_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_mbh = vp8_loop_filter_mbh_sse2;
-    vp8_loop_filter_mbv = vp8_loop_filter_mbv_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_mbv = vp8_loop_filter_mbv_sse2;
-    vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_sse2;
-    vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_sse2;
-    vp8_loop_filter_simple_mbh = vp8_loop_filter_simple_horizontal_edge_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_simple_mbh = vp8_loop_filter_simple_horizontal_edge_sse2;
-    vp8_loop_filter_simple_mbv = vp8_loop_filter_simple_vertical_edge_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_simple_mbv = vp8_loop_filter_simple_vertical_edge_sse2;
-    vp8_mbblock_error = vp8_mbblock_error_c;
-    if (flags & HAS_SSE2) vp8_mbblock_error = vp8_mbblock_error_sse2;
-    vp8_mbuverror = vp8_mbuverror_c;
-    if (flags & HAS_SSE2) vp8_mbuverror = vp8_mbuverror_sse2;
-    vp8_refining_search_sad = vp8_refining_search_sad_c;
-    if (flags & HAS_SSE2) vp8_refining_search_sad = vp8_refining_search_sadx4;
-    vp8_regular_quantize_b = vp8_regular_quantize_b_c;
-    if (flags & HAS_SSE2) vp8_regular_quantize_b = vp8_regular_quantize_b_sse2;
-    if (flags & HAS_SSE4_1) vp8_regular_quantize_b = vp8_regular_quantize_b_sse4_1;
-    vp8_short_fdct4x4 = vp8_short_fdct4x4_c;
-    if (flags & HAS_SSE2) vp8_short_fdct4x4 = vp8_short_fdct4x4_sse2;
-    vp8_short_fdct8x4 = vp8_short_fdct8x4_c;
-    if (flags & HAS_SSE2) vp8_short_fdct8x4 = vp8_short_fdct8x4_sse2;
-    vp8_short_idct4x4llm = vp8_short_idct4x4llm_c;
-    if (flags & HAS_MMX) vp8_short_idct4x4llm = vp8_short_idct4x4llm_mmx;
-    vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_c;
-    if (flags & HAS_SSE2) vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_sse2;
-    vp8_short_walsh4x4 = vp8_short_walsh4x4_c;
-    if (flags & HAS_SSE2) vp8_short_walsh4x4 = vp8_short_walsh4x4_sse2;
-    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_c;
-    if (flags & HAS_SSE2) vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_ssse3;
-    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_c;
-    if (flags & HAS_MMX) vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_mmx;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_ssse3;
-    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_c;
-    if (flags & HAS_SSE2) vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_ssse3;
-    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_c;
-    if (flags & HAS_SSE2) vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_ssse3;
+  vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_c;
+  if (flags & HAS_SSE2)
+    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_ssse3;
+  vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_c;
+  if (flags & HAS_MMX)
+    vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_mmx;
+  vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_c;
+  if (flags & HAS_MMX)
+    vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_mmx;
+  vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_c;
+  if (flags & HAS_SSE2)
+    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_ssse3;
+  vp8_block_error = vp8_block_error_c;
+  if (flags & HAS_SSE2)
+    vp8_block_error = vp8_block_error_sse2;
+  vp8_copy32xn = vp8_copy32xn_c;
+  if (flags & HAS_SSE2)
+    vp8_copy32xn = vp8_copy32xn_sse2;
+  if (flags & HAS_SSE3)
+    vp8_copy32xn = vp8_copy32xn_sse3;
+  vp8_copy_mem16x16 = vp8_copy_mem16x16_c;
+  if (flags & HAS_SSE2)
+    vp8_copy_mem16x16 = vp8_copy_mem16x16_sse2;
+  vp8_copy_mem8x4 = vp8_copy_mem8x4_c;
+  if (flags & HAS_MMX)
+    vp8_copy_mem8x4 = vp8_copy_mem8x4_mmx;
+  vp8_copy_mem8x8 = vp8_copy_mem8x8_c;
+  if (flags & HAS_MMX)
+    vp8_copy_mem8x8 = vp8_copy_mem8x8_mmx;
+  vp8_dc_only_idct_add = vp8_dc_only_idct_add_c;
+  if (flags & HAS_MMX)
+    vp8_dc_only_idct_add = vp8_dc_only_idct_add_mmx;
+  vp8_denoiser_filter = vp8_denoiser_filter_c;
+  if (flags & HAS_SSE2)
+    vp8_denoiser_filter = vp8_denoiser_filter_sse2;
+  vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_c;
+  if (flags & HAS_SSE2)
+    vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_sse2;
+  vp8_dequant_idct_add = vp8_dequant_idct_add_c;
+  if (flags & HAS_MMX)
+    vp8_dequant_idct_add = vp8_dequant_idct_add_mmx;
+  vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_c;
+  if (flags & HAS_SSE2)
+    vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_sse2;
+  vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_c;
+  if (flags & HAS_SSE2)
+    vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_sse2;
+  vp8_dequantize_b = vp8_dequantize_b_c;
+  if (flags & HAS_MMX)
+    vp8_dequantize_b = vp8_dequantize_b_mmx;
+  vp8_diamond_search_sad = vp8_diamond_search_sad_c;
+  if (flags & HAS_SSE2)
+    vp8_diamond_search_sad = vp8_diamond_search_sadx4;
+  vp8_fast_quantize_b = vp8_fast_quantize_b_c;
+  if (flags & HAS_SSE2)
+    vp8_fast_quantize_b = vp8_fast_quantize_b_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_fast_quantize_b = vp8_fast_quantize_b_ssse3;
+  vp8_filter_by_weight16x16 = vp8_filter_by_weight16x16_c;
+  if (flags & HAS_SSE2)
+    vp8_filter_by_weight16x16 = vp8_filter_by_weight16x16_sse2;
+  vp8_filter_by_weight8x8 = vp8_filter_by_weight8x8_c;
+  if (flags & HAS_SSE2)
+    vp8_filter_by_weight8x8 = vp8_filter_by_weight8x8_sse2;
+  vp8_full_search_sad = vp8_full_search_sad_c;
+  if (flags & HAS_SSE3)
+    vp8_full_search_sad = vp8_full_search_sadx3;
+  if (flags & HAS_SSE4_1)
+    vp8_full_search_sad = vp8_full_search_sadx8;
+  vp8_loop_filter_bh = vp8_loop_filter_bh_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_bh = vp8_loop_filter_bh_sse2;
+  vp8_loop_filter_bv = vp8_loop_filter_bv_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_bv = vp8_loop_filter_bv_sse2;
+  vp8_loop_filter_mbh = vp8_loop_filter_mbh_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_mbh = vp8_loop_filter_mbh_sse2;
+  vp8_loop_filter_mbv = vp8_loop_filter_mbv_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_mbv = vp8_loop_filter_mbv_sse2;
+  vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_sse2;
+  vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_sse2;
+  vp8_loop_filter_simple_mbh = vp8_loop_filter_simple_horizontal_edge_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_simple_mbh = vp8_loop_filter_simple_horizontal_edge_sse2;
+  vp8_loop_filter_simple_mbv = vp8_loop_filter_simple_vertical_edge_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_simple_mbv = vp8_loop_filter_simple_vertical_edge_sse2;
+  vp8_mbblock_error = vp8_mbblock_error_c;
+  if (flags & HAS_SSE2)
+    vp8_mbblock_error = vp8_mbblock_error_sse2;
+  vp8_mbuverror = vp8_mbuverror_c;
+  if (flags & HAS_SSE2)
+    vp8_mbuverror = vp8_mbuverror_sse2;
+  vp8_refining_search_sad = vp8_refining_search_sad_c;
+  if (flags & HAS_SSE2)
+    vp8_refining_search_sad = vp8_refining_search_sadx4;
+  vp8_regular_quantize_b = vp8_regular_quantize_b_c;
+  if (flags & HAS_SSE2)
+    vp8_regular_quantize_b = vp8_regular_quantize_b_sse2;
+  if (flags & HAS_SSE4_1)
+    vp8_regular_quantize_b = vp8_regular_quantize_b_sse4_1;
+  vp8_short_fdct4x4 = vp8_short_fdct4x4_c;
+  if (flags & HAS_SSE2)
+    vp8_short_fdct4x4 = vp8_short_fdct4x4_sse2;
+  vp8_short_fdct8x4 = vp8_short_fdct8x4_c;
+  if (flags & HAS_SSE2)
+    vp8_short_fdct8x4 = vp8_short_fdct8x4_sse2;
+  vp8_short_idct4x4llm = vp8_short_idct4x4llm_c;
+  if (flags & HAS_MMX)
+    vp8_short_idct4x4llm = vp8_short_idct4x4llm_mmx;
+  vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_c;
+  if (flags & HAS_SSE2)
+    vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_sse2;
+  vp8_short_walsh4x4 = vp8_short_walsh4x4_c;
+  if (flags & HAS_SSE2)
+    vp8_short_walsh4x4 = vp8_short_walsh4x4_sse2;
+  vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_c;
+  if (flags & HAS_SSE2)
+    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_ssse3;
+  vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_c;
+  if (flags & HAS_MMX)
+    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_mmx;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_ssse3;
+  vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_c;
+  if (flags & HAS_SSE2)
+    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_ssse3;
+  vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_c;
+  if (flags & HAS_SSE2)
+    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_ssse3;
 }
 #endif
 

third_party/libvpx/source/config/mac/ia32/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/mac/ia32/vp9_rtcd.h b/third_party/libvpx/source/config/mac/ia32/vp9_rtcd.h
index 2609a0d..33014a3 100644
--- a/third_party/libvpx/source/config/mac/ia32/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/mac/ia32/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,168 +30,519 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-int64_t vp9_block_error_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-int64_t vp9_block_error_avx2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-RTCD_EXTERN int64_t (*vp9_block_error)(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
+int64_t vp9_block_error_sse2(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             intptr_t block_size,
+                             int64_t* ssz);
+int64_t vp9_block_error_avx2(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             intptr_t block_size,
+                             int64_t* ssz);
+RTCD_EXTERN int64_t (*vp9_block_error)(const tran_low_t* coeff,
+                                       const tran_low_t* dqcoeff,
+                                       intptr_t block_size,
+                                       int64_t* ssz);
 
-int64_t vp9_block_error_fp_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
-int64_t vp9_block_error_fp_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
-RTCD_EXTERN int64_t (*vp9_block_error_fp)(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             int block_size);
+int64_t vp9_block_error_fp_sse2(const tran_low_t* coeff,
+                                const tran_low_t* dqcoeff,
+                                int block_size);
+RTCD_EXTERN int64_t (*vp9_block_error_fp)(const tran_low_t* coeff,
+                                          const tran_low_t* dqcoeff,
+                                          int block_size);
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-int vp9_denoiser_filter_sse2(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-RTCD_EXTERN int (*vp9_denoiser_filter)(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
+int vp9_denoiser_filter_sse2(const uint8_t* sig,
+                             int sig_stride,
+                             const uint8_t* mc_avg,
+                             int mc_avg_stride,
+                             uint8_t* avg,
+                             int avg_stride,
+                             int increase_denoising,
+                             BLOCK_SIZE bs,
+                             int motion_magnitude);
+RTCD_EXTERN int (*vp9_denoiser_filter)(const uint8_t* sig,
+                                       int sig_stride,
+                                       const uint8_t* mc_avg,
+                                       int mc_avg_stride,
+                                       uint8_t* avg,
+                                       int avg_stride,
+                                       int increase_denoising,
+                                       BLOCK_SIZE bs,
+                                       int motion_magnitude);
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
-int vp9_diamond_search_sad_avx(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
-RTCD_EXTERN int (*vp9_diamond_search_sad)(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
+int vp9_diamond_search_sad_avx(const struct macroblock* x,
+                               const struct search_site_config* cfg,
+                               struct mv* ref_mv,
+                               struct mv* best_mv,
+                               int search_param,
+                               int sad_per_bit,
+                               int* num00,
+                               const struct vp9_variance_vtable* fn_ptr,
+                               const struct mv* center_mv);
+RTCD_EXTERN int (*vp9_diamond_search_sad)(
+    const struct macroblock* x,
+    const struct search_site_config* cfg,
+    struct mv* ref_mv,
+    struct mv* best_mv,
+    int search_param,
+    int sad_per_bit,
+    int* num00,
+    const struct vp9_variance_vtable* fn_ptr,
+    const struct mv* center_mv);
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_fdct8x8_quant_ssse3(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_fdct8x8_quant)(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+void vp9_fdct8x8_quant_ssse3(const int16_t* input,
+                             int stride,
+                             tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+RTCD_EXTERN void (*vp9_fdct8x8_quant)(const int16_t* input,
+                                      int stride,
+                                      tran_low_t* coeff_ptr,
+                                      intptr_t n_coeffs,
+                                      int skip_block,
+                                      const int16_t* round_ptr,
+                                      const int16_t* quant_ptr,
+                                      tran_low_t* qcoeff_ptr,
+                                      tran_low_t* dqcoeff_ptr,
+                                      const int16_t* dequant_ptr,
+                                      uint16_t* eob_ptr,
+                                      const int16_t* scan,
+                                      const int16_t* iscan);
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht16x16_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_fht16x16)(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
+void vp9_fht16x16_sse2(const int16_t* input,
+                       tran_low_t* output,
+                       int stride,
+                       int tx_type);
+RTCD_EXTERN void (*vp9_fht16x16)(const int16_t* input,
+                                 tran_low_t* output,
+                                 int stride,
+                                 int tx_type);
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht4x4_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_fht4x4)(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
+void vp9_fht4x4_sse2(const int16_t* input,
+                     tran_low_t* output,
+                     int stride,
+                     int tx_type);
+RTCD_EXTERN void (*vp9_fht4x4)(const int16_t* input,
+                               tran_low_t* output,
+                               int stride,
+                               int tx_type);
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht8x8_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_fht8x8)(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
+void vp9_fht8x8_sse2(const int16_t* input,
+                     tran_low_t* output,
+                     int stride,
+                     int tx_type);
+RTCD_EXTERN void (*vp9_fht8x8)(const int16_t* input,
+                               tran_low_t* output,
+                               int stride,
+                               int tx_type);
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-void vp9_filter_by_weight16x16_sse2(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-RTCD_EXTERN void (*vp9_filter_by_weight16x16)(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
+void vp9_filter_by_weight16x16_sse2(const uint8_t* src,
+                                    int src_stride,
+                                    uint8_t* dst,
+                                    int dst_stride,
+                                    int src_weight);
+RTCD_EXTERN void (*vp9_filter_by_weight16x16)(const uint8_t* src,
+                                              int src_stride,
+                                              uint8_t* dst,
+                                              int dst_stride,
+                                              int src_weight);
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-void vp9_filter_by_weight8x8_sse2(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-RTCD_EXTERN void (*vp9_filter_by_weight8x8)(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
+void vp9_filter_by_weight8x8_sse2(const uint8_t* src,
+                                  int src_stride,
+                                  uint8_t* dst,
+                                  int dst_stride,
+                                  int src_weight);
+RTCD_EXTERN void (*vp9_filter_by_weight8x8)(const uint8_t* src,
+                                            int src_stride,
+                                            uint8_t* dst,
+                                            int dst_stride,
+                                            int src_weight);
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vp9_fwht4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vp9_fwht4x4)(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vp9_fwht4x4_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vp9_fwht4x4)(const int16_t* input,
+                                tran_low_t* output,
+                                int stride);
 
-int64_t vp9_highbd_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
-int64_t vp9_highbd_block_error_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
-RTCD_EXTERN int64_t (*vp9_highbd_block_error)(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
+int64_t vp9_highbd_block_error_c(const tran_low_t* coeff,
+                                 const tran_low_t* dqcoeff,
+                                 intptr_t block_size,
+                                 int64_t* ssz,
+                                 int bd);
+int64_t vp9_highbd_block_error_sse2(const tran_low_t* coeff,
+                                    const tran_low_t* dqcoeff,
+                                    intptr_t block_size,
+                                    int64_t* ssz,
+                                    int bd);
+RTCD_EXTERN int64_t (*vp9_highbd_block_error)(const tran_low_t* coeff,
+                                              const tran_low_t* dqcoeff,
+                                              intptr_t block_size,
+                                              int64_t* ssz,
+                                              int bd);
 
-void vp9_highbd_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht16x16_c(const int16_t* input,
+                           tran_low_t* output,
+                           int stride,
+                           int tx_type);
 #define vp9_highbd_fht16x16 vp9_highbd_fht16x16_c
 
-void vp9_highbd_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht4x4_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht4x4 vp9_highbd_fht4x4_c
 
-void vp9_highbd_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht8x8_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht8x8 vp9_highbd_fht8x8_c
 
-void vp9_highbd_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_highbd_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_highbd_fwht4x4 vp9_highbd_fwht4x4_c
 
-void vp9_highbd_iht16x16_256_add_c(const tran_low_t *input, uint16_t *output, int pitch, int tx_type, int bd);
+void vp9_highbd_iht16x16_256_add_c(const tran_low_t* input,
+                                   uint16_t* output,
+                                   int pitch,
+                                   int tx_type,
+                                   int bd);
 #define vp9_highbd_iht16x16_256_add vp9_highbd_iht16x16_256_add_c
 
-void vp9_highbd_iht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht4x4_16_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht4x4_16_add vp9_highbd_iht4x4_16_add_c
 
-void vp9_highbd_iht8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht8x8_64_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht8x8_64_add vp9_highbd_iht8x8_64_add_c
 
-void vp9_highbd_mbpost_proc_across_ip_c(uint16_t *src, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_across_ip_c(uint16_t* src,
+                                        int pitch,
+                                        int rows,
+                                        int cols,
+                                        int flimit);
 #define vp9_highbd_mbpost_proc_across_ip vp9_highbd_mbpost_proc_across_ip_c
 
-void vp9_highbd_mbpost_proc_down_c(uint16_t *dst, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_down_c(uint16_t* dst,
+                                   int pitch,
+                                   int rows,
+                                   int cols,
+                                   int flimit);
 #define vp9_highbd_mbpost_proc_down vp9_highbd_mbpost_proc_down_c
 
-void vp9_highbd_post_proc_down_and_across_c(const uint16_t *src_ptr, uint16_t *dst_ptr, int src_pixels_per_line, int dst_pixels_per_line, int rows, int cols, int flimit);
-#define vp9_highbd_post_proc_down_and_across vp9_highbd_post_proc_down_and_across_c
+void vp9_highbd_post_proc_down_and_across_c(const uint16_t* src_ptr,
+                                            uint16_t* dst_ptr,
+                                            int src_pixels_per_line,
+                                            int dst_pixels_per_line,
+                                            int rows,
+                                            int cols,
+                                            int flimit);
+#define vp9_highbd_post_proc_down_and_across \
+  vp9_highbd_post_proc_down_and_across_c
 
-void vp9_highbd_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_c(const tran_low_t* coeff_ptr,
+                              intptr_t n_coeffs,
+                              int skip_block,
+                              const int16_t* round_ptr,
+                              const int16_t* quant_ptr,
+                              tran_low_t* qcoeff_ptr,
+                              tran_low_t* dqcoeff_ptr,
+                              const int16_t* dequant_ptr,
+                              uint16_t* eob_ptr,
+                              const int16_t* scan,
+                              const int16_t* iscan);
 #define vp9_highbd_quantize_fp vp9_highbd_quantize_fp_c
 
-void vp9_highbd_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 #define vp9_highbd_quantize_fp_32x32 vp9_highbd_quantize_fp_32x32_c
 
-void vp9_highbd_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_highbd_temporal_filter_apply_c(const uint8_t* frame1,
+                                        unsigned int stride,
+                                        const uint8_t* frame2,
+                                        unsigned int block_width,
+                                        unsigned int block_height,
+                                        int strength,
+                                        int filter_weight,
+                                        uint32_t* accumulator,
+                                        uint16_t* count);
 #define vp9_highbd_temporal_filter_apply vp9_highbd_temporal_filter_apply_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
-void vp9_iht16x16_256_add_sse2(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
-RTCD_EXTERN void (*vp9_iht16x16_256_add)(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
+void vp9_iht16x16_256_add_sse2(const tran_low_t* input,
+                               uint8_t* output,
+                               int pitch,
+                               int tx_type);
+RTCD_EXTERN void (*vp9_iht16x16_256_add)(const tran_low_t* input,
+                                         uint8_t* output,
+                                         int pitch,
+                                         int tx_type);
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_iht4x4_16_add)(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht4x4_16_add_sse2(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
+RTCD_EXTERN void (*vp9_iht4x4_16_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride,
+                                      int tx_type);
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht8x8_64_add_sse2(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_iht8x8_64_add)(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht8x8_64_add_sse2(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
+RTCD_EXTERN void (*vp9_iht8x8_64_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride,
+                                      int tx_type);
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_quantize_fp)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
+void vp9_quantize_fp_sse2(const tran_low_t* coeff_ptr,
+                          intptr_t n_coeffs,
+                          int skip_block,
+                          const int16_t* round_ptr,
+                          const int16_t* quant_ptr,
+                          tran_low_t* qcoeff_ptr,
+                          tran_low_t* dqcoeff_ptr,
+                          const int16_t* dequant_ptr,
+                          uint16_t* eob_ptr,
+                          const int16_t* scan,
+                          const int16_t* iscan);
+RTCD_EXTERN void (*vp9_quantize_fp)(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vp9_quantize_fp_32x32 vp9_quantize_fp_32x32_c
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
-void vp9_scale_and_extend_frame_ssse3(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
-RTCD_EXTERN void (*vp9_scale_and_extend_frame)(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
+void vp9_scale_and_extend_frame_ssse3(const struct yv12_buffer_config* src,
+                                      struct yv12_buffer_config* dst,
+                                      INTERP_FILTER filter_type,
+                                      int phase_scaler);
+RTCD_EXTERN void (*vp9_scale_and_extend_frame)(
+    const struct yv12_buffer_config* src,
+    struct yv12_buffer_config* dst,
+    INTERP_FILTER filter_type,
+    int phase_scaler);
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
-void vp9_temporal_filter_apply_sse4_1(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
-RTCD_EXTERN void (*vp9_temporal_filter_apply)(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
+void vp9_temporal_filter_apply_sse4_1(const uint8_t* frame1,
+                                      unsigned int stride,
+                                      const uint8_t* frame2,
+                                      unsigned int block_width,
+                                      unsigned int block_height,
+                                      int strength,
+                                      int filter_weight,
+                                      uint32_t* accumulator,
+                                      uint16_t* count);
+RTCD_EXTERN void (*vp9_temporal_filter_apply)(const uint8_t* frame1,
+                                              unsigned int stride,
+                                              const uint8_t* frame2,
+                                              unsigned int block_width,
+                                              unsigned int block_height,
+                                              int strength,
+                                              int filter_weight,
+                                              uint32_t* accumulator,
+                                              uint16_t* count);
 
 void vp9_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vp9_block_error = vp9_block_error_c;
-    if (flags & HAS_SSE2) vp9_block_error = vp9_block_error_sse2;
-    if (flags & HAS_AVX2) vp9_block_error = vp9_block_error_avx2;
-    vp9_block_error_fp = vp9_block_error_fp_c;
-    if (flags & HAS_SSE2) vp9_block_error_fp = vp9_block_error_fp_sse2;
-    vp9_denoiser_filter = vp9_denoiser_filter_c;
-    if (flags & HAS_SSE2) vp9_denoiser_filter = vp9_denoiser_filter_sse2;
-    vp9_diamond_search_sad = vp9_diamond_search_sad_c;
-    if (flags & HAS_AVX) vp9_diamond_search_sad = vp9_diamond_search_sad_avx;
-    vp9_fdct8x8_quant = vp9_fdct8x8_quant_c;
-    if (flags & HAS_SSSE3) vp9_fdct8x8_quant = vp9_fdct8x8_quant_ssse3;
-    vp9_fht16x16 = vp9_fht16x16_c;
-    if (flags & HAS_SSE2) vp9_fht16x16 = vp9_fht16x16_sse2;
-    vp9_fht4x4 = vp9_fht4x4_c;
-    if (flags & HAS_SSE2) vp9_fht4x4 = vp9_fht4x4_sse2;
-    vp9_fht8x8 = vp9_fht8x8_c;
-    if (flags & HAS_SSE2) vp9_fht8x8 = vp9_fht8x8_sse2;
-    vp9_filter_by_weight16x16 = vp9_filter_by_weight16x16_c;
-    if (flags & HAS_SSE2) vp9_filter_by_weight16x16 = vp9_filter_by_weight16x16_sse2;
-    vp9_filter_by_weight8x8 = vp9_filter_by_weight8x8_c;
-    if (flags & HAS_SSE2) vp9_filter_by_weight8x8 = vp9_filter_by_weight8x8_sse2;
-    vp9_fwht4x4 = vp9_fwht4x4_c;
-    if (flags & HAS_SSE2) vp9_fwht4x4 = vp9_fwht4x4_sse2;
-    vp9_highbd_block_error = vp9_highbd_block_error_c;
-    if (flags & HAS_SSE2) vp9_highbd_block_error = vp9_highbd_block_error_sse2;
-    vp9_iht16x16_256_add = vp9_iht16x16_256_add_c;
-    if (flags & HAS_SSE2) vp9_iht16x16_256_add = vp9_iht16x16_256_add_sse2;
-    vp9_iht4x4_16_add = vp9_iht4x4_16_add_c;
-    if (flags & HAS_SSE2) vp9_iht4x4_16_add = vp9_iht4x4_16_add_sse2;
-    vp9_iht8x8_64_add = vp9_iht8x8_64_add_c;
-    if (flags & HAS_SSE2) vp9_iht8x8_64_add = vp9_iht8x8_64_add_sse2;
-    vp9_quantize_fp = vp9_quantize_fp_c;
-    if (flags & HAS_SSE2) vp9_quantize_fp = vp9_quantize_fp_sse2;
-    vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_c;
-    if (flags & HAS_SSSE3) vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_ssse3;
-    vp9_temporal_filter_apply = vp9_temporal_filter_apply_c;
-    if (flags & HAS_SSE4_1) vp9_temporal_filter_apply = vp9_temporal_filter_apply_sse4_1;
+  vp9_block_error = vp9_block_error_c;
+  if (flags & HAS_SSE2)
+    vp9_block_error = vp9_block_error_sse2;
+  if (flags & HAS_AVX2)
+    vp9_block_error = vp9_block_error_avx2;
+  vp9_block_error_fp = vp9_block_error_fp_c;
+  if (flags & HAS_SSE2)
+    vp9_block_error_fp = vp9_block_error_fp_sse2;
+  vp9_denoiser_filter = vp9_denoiser_filter_c;
+  if (flags & HAS_SSE2)
+    vp9_denoiser_filter = vp9_denoiser_filter_sse2;
+  vp9_diamond_search_sad = vp9_diamond_search_sad_c;
+  if (flags & HAS_AVX)
+    vp9_diamond_search_sad = vp9_diamond_search_sad_avx;
+  vp9_fdct8x8_quant = vp9_fdct8x8_quant_c;
+  if (flags & HAS_SSSE3)
+    vp9_fdct8x8_quant = vp9_fdct8x8_quant_ssse3;
+  vp9_fht16x16 = vp9_fht16x16_c;
+  if (flags & HAS_SSE2)
+    vp9_fht16x16 = vp9_fht16x16_sse2;
+  vp9_fht4x4 = vp9_fht4x4_c;
+  if (flags & HAS_SSE2)
+    vp9_fht4x4 = vp9_fht4x4_sse2;
+  vp9_fht8x8 = vp9_fht8x8_c;
+  if (flags & HAS_SSE2)
+    vp9_fht8x8 = vp9_fht8x8_sse2;
+  vp9_filter_by_weight16x16 = vp9_filter_by_weight16x16_c;
+  if (flags & HAS_SSE2)
+    vp9_filter_by_weight16x16 = vp9_filter_by_weight16x16_sse2;
+  vp9_filter_by_weight8x8 = vp9_filter_by_weight8x8_c;
+  if (flags & HAS_SSE2)
+    vp9_filter_by_weight8x8 = vp9_filter_by_weight8x8_sse2;
+  vp9_fwht4x4 = vp9_fwht4x4_c;
+  if (flags & HAS_SSE2)
+    vp9_fwht4x4 = vp9_fwht4x4_sse2;
+  vp9_highbd_block_error = vp9_highbd_block_error_c;
+  if (flags & HAS_SSE2)
+    vp9_highbd_block_error = vp9_highbd_block_error_sse2;
+  vp9_iht16x16_256_add = vp9_iht16x16_256_add_c;
+  if (flags & HAS_SSE2)
+    vp9_iht16x16_256_add = vp9_iht16x16_256_add_sse2;
+  vp9_iht4x4_16_add = vp9_iht4x4_16_add_c;
+  if (flags & HAS_SSE2)
+    vp9_iht4x4_16_add = vp9_iht4x4_16_add_sse2;
+  vp9_iht8x8_64_add = vp9_iht8x8_64_add_c;
+  if (flags & HAS_SSE2)
+    vp9_iht8x8_64_add = vp9_iht8x8_64_add_sse2;
+  vp9_quantize_fp = vp9_quantize_fp_c;
+  if (flags & HAS_SSE2)
+    vp9_quantize_fp = vp9_quantize_fp_sse2;
+  vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_c;
+  if (flags & HAS_SSSE3)
+    vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_ssse3;
+  vp9_temporal_filter_apply = vp9_temporal_filter_apply_c;
+  if (flags & HAS_SSE4_1)
+    vp9_temporal_filter_apply = vp9_temporal_filter_apply_sse4_1;
 }
 #endif
 

third_party/libvpx/source/config/mac/ia32/vpx_config.asm

diff --git a/third_party/libvpx/source/config/mac/ia32/vpx_config.asm b/third_party/libvpx/source/config/mac/ia32/vpx_config.asm
index f4375a0f..22d07d6 100644
--- a/third_party/libvpx/source/config/mac/ia32/vpx_config.asm
+++ b/third_party/libvpx/source/config/mac/ia32/vpx_config.asm
@@ -18,6 +18,7 @@
 %define HAVE_AVX 1
 %define HAVE_AVX2 1
 %define HAVE_VSX 0
+%define HAVE_MMI 0
 %define HAVE_VPX_PORTS 1
 %define HAVE_PTHREAD_H 1
 %define HAVE_UNISTD_H 0

third_party/libvpx/source/config/mac/ia32/vpx_config.h

diff --git a/third_party/libvpx/source/config/mac/ia32/vpx_config.h b/third_party/libvpx/source/config/mac/ia32/vpx_config.h
index 65d869f..5279532 100644
--- a/third_party/libvpx/source/config/mac/ia32/vpx_config.h
+++ b/third_party/libvpx/source/config/mac/ia32/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 1
 #define HAVE_AVX2 1
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/mac/ia32/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/mac/ia32/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/mac/ia32/vpx_dsp_rtcd.h
index 58cad7f6..b463d4b37 100644
--- a/third_party/libvpx/source/config/mac/ia32/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/mac/ia32/vpx_dsp_rtcd.h
@@ -14,2807 +14,9640 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
-unsigned int vpx_avg_4x4_sse2(const uint8_t *, int p);
-RTCD_EXTERN unsigned int (*vpx_avg_4x4)(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
+unsigned int vpx_avg_4x4_sse2(const uint8_t*, int p);
+RTCD_EXTERN unsigned int (*vpx_avg_4x4)(const uint8_t*, int p);
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
-unsigned int vpx_avg_8x8_sse2(const uint8_t *, int p);
-RTCD_EXTERN unsigned int (*vpx_avg_8x8)(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
+unsigned int vpx_avg_8x8_sse2(const uint8_t*, int p);
+RTCD_EXTERN unsigned int (*vpx_avg_8x8)(const uint8_t*, int p);
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-void vpx_comp_avg_pred_sse2(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-RTCD_EXTERN void (*vpx_comp_avg_pred)(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
+void vpx_comp_avg_pred_sse2(uint8_t* comp_pred,
+                            const uint8_t* pred,
+                            int width,
+                            int height,
+                            const uint8_t* ref,
+                            int ref_stride);
+RTCD_EXTERN void (*vpx_comp_avg_pred)(uint8_t* comp_pred,
+                                      const uint8_t* pred,
+                                      int width,
+                                      int height,
+                                      const uint8_t* ref,
+                                      int ref_stride);
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_convolve8_sse2(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve8_ssse3(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avx2(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+RTCD_EXTERN void (*vpx_convolve8)(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avg_sse2(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
+void vpx_convolve8_avg_ssse3(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+RTCD_EXTERN void (*vpx_convolve8_avg)(const uint8_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h);
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg_horiz)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_avg_horiz_sse2(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
+void vpx_convolve8_avg_horiz_ssse3(const uint8_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h);
+RTCD_EXTERN void (*vpx_convolve8_avg_horiz)(const uint8_t* src,
+                                            ptrdiff_t src_stride,
+                                            uint8_t* dst,
+                                            ptrdiff_t dst_stride,
+                                            const int16_t* filter_x,
+                                            int x_step_q4,
+                                            const int16_t* filter_y,
+                                            int y_step_q4,
+                                            int w,
+                                            int h);
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg_vert)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_avg_vert_sse2(const uint8_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h);
+void vpx_convolve8_avg_vert_ssse3(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
+RTCD_EXTERN void (*vpx_convolve8_avg_vert)(const uint8_t* src,
+                                           ptrdiff_t src_stride,
+                                           uint8_t* dst,
+                                           ptrdiff_t dst_stride,
+                                           const int16_t* filter_x,
+                                           int x_step_q4,
+                                           const int16_t* filter_y,
+                                           int y_step_q4,
+                                           int w,
+                                           int h);
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_horiz)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+void vpx_convolve8_horiz_sse2(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_horiz_ssse3(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_horiz_avx2(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+RTCD_EXTERN void (*vpx_convolve8_horiz)(const uint8_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint8_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h);
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_vert)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
+void vpx_convolve8_vert_sse2(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+void vpx_convolve8_vert_ssse3(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_vert_avx2(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+RTCD_EXTERN void (*vpx_convolve8_vert)(const uint8_t* src,
+                                       ptrdiff_t src_stride,
+                                       uint8_t* dst,
+                                       ptrdiff_t dst_stride,
+                                       const int16_t* filter_x,
+                                       int x_step_q4,
+                                       const int16_t* filter_y,
+                                       int y_step_q4,
+                                       int w,
+                                       int h);
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_avg_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve_avg)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve_avg_sse2(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+RTCD_EXTERN void (*vpx_convolve_avg)(const uint8_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint8_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h);
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_copy_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve_copy)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve_copy_sse2(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
+RTCD_EXTERN void (*vpx_convolve_copy)(const uint8_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h);
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_c
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_c
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_c
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_c
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d153_predictor_16x16_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_16x16)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d153_predictor_32x32_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_32x32)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_4x4_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d153_predictor_4x4_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_4x4)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d153_predictor_8x8_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_8x8)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d207_predictor_16x16_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_16x16)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d207_predictor_32x32_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_32x32)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d207_predictor_4x4_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_4x4)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d207_predictor_8x8_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_8x8)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_16x16_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_16x16)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_32x32_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_32x32)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_4x4_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_4x4)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_8x8_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_8x8)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d63_predictor_16x16_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_16x16)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d63_predictor_32x32_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_32x32)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_4x4_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d63_predictor_4x4_ssse3(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_4x4)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d63_predictor_8x8_ssse3(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_8x8)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_16x16_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_16x16)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_32x32_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_32x32)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_4x4_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_4x4)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_8x8_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_8x8)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_16x16_sse2(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_16x16)(uint8_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint8_t* above,
+                                                const uint8_t* left);
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_32x32_sse2(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_32x32)(uint8_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint8_t* above,
+                                                const uint8_t* left);
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_4x4_sse2(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_4x4)(uint8_t* dst,
+                                              ptrdiff_t y_stride,
+                                              const uint8_t* above,
+                                              const uint8_t* left);
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_8x8_sse2(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_8x8)(uint8_t* dst,
+                                              ptrdiff_t y_stride,
+                                              const uint8_t* above,
+                                              const uint8_t* left);
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_16x16_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_16x16)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_32x32_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_32x32)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_4x4_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_4x4)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_8x8_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_8x8)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_16x16_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_16x16)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_32x32_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_32x32)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_4x4_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_4x4)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_8x8_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_8x8)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct16x16)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct16x16)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_1_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct16x16_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_1_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct16x16_1)(const int16_t* input,
+                                    tran_low_t* output,
+                                    int stride);
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct32x32)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct32x32)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_1_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct32x32_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_1_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct32x32_1)(const int16_t* input,
+                                    tran_low_t* output,
+                                    int stride);
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_rd_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct32x32_rd)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_rd_sse2(const int16_t* input,
+                           tran_low_t* output,
+                           int stride);
+RTCD_EXTERN void (*vpx_fdct32x32_rd)(const int16_t* input,
+                                     tran_low_t* output,
+                                     int stride);
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct4x4)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct4x4)(const int16_t* input,
+                                tran_low_t* output,
+                                int stride);
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_1_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct4x4_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_1_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct4x4_1)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct8x8)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct8x8)(const int16_t* input,
+                                tran_low_t* output,
+                                int stride);
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_1_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct8x8_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_1_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct8x8_1)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-RTCD_EXTERN void (*vpx_get16x16var)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
+void vpx_get16x16var_sse2(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
+void vpx_get16x16var_avx2(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
+RTCD_EXTERN void (*vpx_get16x16var)(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse,
+                                    int* sum);
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_c
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get8x8var_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-RTCD_EXTERN void (*vpx_get8x8var)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
+void vpx_get8x8var_sse2(const uint8_t* src_ptr,
+                        int source_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        unsigned int* sse,
+                        int* sum);
+RTCD_EXTERN void (*vpx_get8x8var)(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse,
+                                  int* sum);
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
-unsigned int vpx_get_mb_ss_sse2(const int16_t *);
-RTCD_EXTERN unsigned int (*vpx_get_mb_ss)(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
+unsigned int vpx_get_mb_ss_sse2(const int16_t*);
+RTCD_EXTERN unsigned int (*vpx_get_mb_ss)(const int16_t*);
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_16x16_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_16x16)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_32x32_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_32x32)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_4x4_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_4x4)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_8x8_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_8x8)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_16x16_sse2(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-RTCD_EXTERN void (*vpx_hadamard_16x16)(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          tran_low_t* coeff);
+void vpx_hadamard_16x16_sse2(const int16_t* src_diff,
+                             int src_stride,
+                             tran_low_t* coeff);
+RTCD_EXTERN void (*vpx_hadamard_16x16)(const int16_t* src_diff,
+                                       int src_stride,
+                                       tran_low_t* coeff);
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_8x8_sse2(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-RTCD_EXTERN void (*vpx_hadamard_8x8)(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        tran_low_t* coeff);
+void vpx_hadamard_8x8_sse2(const int16_t* src_diff,
+                           int src_stride,
+                           tran_low_t* coeff);
+RTCD_EXTERN void (*vpx_hadamard_8x8)(const int16_t* src_diff,
+                                     int src_stride,
+                                     tran_low_t* coeff);
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_highbd_10_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_10_get16x16var vpx_highbd_10_get16x16var_c
 
-void vpx_highbd_10_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_10_get8x8var vpx_highbd_10_get8x8var_c
 
-unsigned int vpx_highbd_10_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+unsigned int vpx_highbd_10_mse16x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_mse16x16)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   const uint8_t* ref_ptr,
+                                                   int recon_stride,
+                                                   unsigned int* sse);
 
-unsigned int vpx_highbd_10_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse16x8 vpx_highbd_10_mse16x8_c
 
-unsigned int vpx_highbd_10_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse8x16 vpx_highbd_10_mse8x16_c
 
-unsigned int vpx_highbd_10_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_mse8x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
+unsigned int vpx_highbd_10_mse8x8_sse2(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_mse8x8)(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 const uint8_t* ref_ptr,
+                                                 int recon_stride,
+                                                 unsigned int* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x4 vpx_highbd_10_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x4 \
+  vpx_highbd_10_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x8 vpx_highbd_10_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x8 \
+  vpx_highbd_10_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x4 vpx_highbd_10_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x4 \
+  vpx_highbd_10_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x8 vpx_highbd_10_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x8 \
+  vpx_highbd_10_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-unsigned int vpx_highbd_10_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x16)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x8)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x16)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x64)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x4 vpx_highbd_10_variance4x4_c
 
-unsigned int vpx_highbd_10_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x8 vpx_highbd_10_variance4x8_c
 
-unsigned int vpx_highbd_10_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance64x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance64x64)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance8x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_10_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance8x16)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance8x4 vpx_highbd_10_variance8x4_c
 
-unsigned int vpx_highbd_10_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance8x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_10_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance8x8)(const uint8_t* src_ptr,
+                                                      int source_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride,
+                                                      unsigned int* sse);
 
-void vpx_highbd_12_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_12_get16x16var vpx_highbd_12_get16x16var_c
 
-void vpx_highbd_12_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_12_get8x8var vpx_highbd_12_get8x8var_c
 
-unsigned int vpx_highbd_12_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+unsigned int vpx_highbd_12_mse16x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_mse16x16)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   const uint8_t* ref_ptr,
+                                                   int recon_stride,
+                                                   unsigned int* sse);
 
-unsigned int vpx_highbd_12_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse16x8 vpx_highbd_12_mse16x8_c
 
-unsigned int vpx_highbd_12_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse8x16 vpx_highbd_12_mse8x16_c
 
-unsigned int vpx_highbd_12_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_mse8x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
+unsigned int vpx_highbd_12_mse8x8_sse2(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_mse8x8)(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 const uint8_t* ref_ptr,
+                                                 int recon_stride,
+                                                 unsigned int* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x4 vpx_highbd_12_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x4 \
+  vpx_highbd_12_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x8 vpx_highbd_12_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x8 \
+  vpx_highbd_12_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x4 vpx_highbd_12_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x4 \
+  vpx_highbd_12_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x8 vpx_highbd_12_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x8 \
+  vpx_highbd_12_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-unsigned int vpx_highbd_12_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x16)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x8)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x16)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x64)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x4 vpx_highbd_12_variance4x4_c
 
-unsigned int vpx_highbd_12_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x8 vpx_highbd_12_variance4x8_c
 
-unsigned int vpx_highbd_12_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance64x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance64x64)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance8x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_12_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance8x16)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance8x4 vpx_highbd_12_variance8x4_c
 
-unsigned int vpx_highbd_12_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance8x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_12_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance8x8)(const uint8_t* src_ptr,
+                                                      int source_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride,
+                                                      unsigned int* sse);
 
-void vpx_highbd_8_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get16x16var_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse,
+                                int* sum);
 #define vpx_highbd_8_get16x16var vpx_highbd_8_get16x16var_c
 
-void vpx_highbd_8_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get8x8var_c(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              unsigned int* sse,
+                              int* sum);
 #define vpx_highbd_8_get8x8var vpx_highbd_8_get8x8var_c
 
-unsigned int vpx_highbd_8_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
+unsigned int vpx_highbd_8_mse16x16_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int recon_stride,
+                                        unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_mse16x16)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  const uint8_t* ref_ptr,
+                                                  int recon_stride,
+                                                  unsigned int* sse);
 
-unsigned int vpx_highbd_8_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse16x8 vpx_highbd_8_mse16x8_c
 
-unsigned int vpx_highbd_8_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x16_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse8x16 vpx_highbd_8_mse8x16_c
 
-unsigned int vpx_highbd_8_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_mse8x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x8_c(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int recon_stride,
+                                   unsigned int* sse);
+unsigned int vpx_highbd_8_mse8x8_sse2(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_mse8x8)(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                const uint8_t* ref_ptr,
+                                                int recon_stride,
+                                                unsigned int* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x4 vpx_highbd_8_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x4 \
+  vpx_highbd_8_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x8 vpx_highbd_8_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x8 \
+  vpx_highbd_8_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x4 vpx_highbd_8_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x8 vpx_highbd_8_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-unsigned int vpx_highbd_8_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x16)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x32)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x8)(const uint8_t* src_ptr,
+                                                      int source_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride,
+                                                      unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x16)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x32)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x64_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x64)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x4 vpx_highbd_8_variance4x4_c
 
-unsigned int vpx_highbd_8_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x8 vpx_highbd_8_variance4x8_c
 
-unsigned int vpx_highbd_8_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance64x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance64x32)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance64x64_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance64x64)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance8x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x16_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_8_variance8x16_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance8x16)(const uint8_t* src_ptr,
+                                                      int source_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride,
+                                                      unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance8x4 vpx_highbd_8_variance8x4_c
 
-unsigned int vpx_highbd_8_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance8x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
+unsigned int vpx_highbd_8_variance8x8_sse2(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance8x8)(const uint8_t* src_ptr,
+                                                     int source_stride,
+                                                     const uint8_t* ref_ptr,
+                                                     int ref_stride,
+                                                     unsigned int* sse);
 
-unsigned int vpx_highbd_avg_4x4_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_4x4_c(const uint8_t*, int p);
 #define vpx_highbd_avg_4x4 vpx_highbd_avg_4x4_c
 
-unsigned int vpx_highbd_avg_8x8_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_8x8_c(const uint8_t*, int p);
 #define vpx_highbd_avg_8x8 vpx_highbd_avg_8x8_c
 
-void vpx_highbd_comp_avg_pred_c(uint16_t *comp_pred, const uint8_t *pred8, int width, int height, const uint8_t *ref8, int ref_stride);
+void vpx_highbd_comp_avg_pred_c(uint16_t* comp_pred,
+                                const uint8_t* pred8,
+                                int width,
+                                int height,
+                                const uint8_t* ref8,
+                                int ref_stride);
 #define vpx_highbd_comp_avg_pred vpx_highbd_comp_avg_pred_c
 
-void vpx_highbd_convolve8_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_c(const uint16_t* src,
+                            ptrdiff_t src_stride,
+                            uint16_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h,
+                            int bps);
+void vpx_highbd_convolve8_avx2(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8)(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
 
-void vpx_highbd_convolve8_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
+void vpx_highbd_convolve8_avg_avx2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg)(const uint16_t* src,
+                                             ptrdiff_t src_stride,
+                                             uint16_t* dst,
+                                             ptrdiff_t dst_stride,
+                                             const int16_t* filter_x,
+                                             int x_step_q4,
+                                             const int16_t* filter_y,
+                                             int y_step_q4,
+                                             int w,
+                                             int h,
+                                             int bps);
 
-void vpx_highbd_convolve8_avg_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_horiz_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg_horiz)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_horiz_c(const uint16_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint16_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h,
+                                      int bps);
+void vpx_highbd_convolve8_avg_horiz_avx2(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg_horiz)(const uint16_t* src,
+                                                   ptrdiff_t src_stride,
+                                                   uint16_t* dst,
+                                                   ptrdiff_t dst_stride,
+                                                   const int16_t* filter_x,
+                                                   int x_step_q4,
+                                                   const int16_t* filter_y,
+                                                   int y_step_q4,
+                                                   int w,
+                                                   int h,
+                                                   int bps);
 
-void vpx_highbd_convolve8_avg_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_vert_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg_vert)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_vert_c(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+void vpx_highbd_convolve8_avg_vert_avx2(const uint16_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint16_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h,
+                                        int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg_vert)(const uint16_t* src,
+                                                  ptrdiff_t src_stride,
+                                                  uint16_t* dst,
+                                                  ptrdiff_t dst_stride,
+                                                  const int16_t* filter_x,
+                                                  int x_step_q4,
+                                                  const int16_t* filter_y,
+                                                  int y_step_q4,
+                                                  int w,
+                                                  int h,
+                                                  int bps);
 
-void vpx_highbd_convolve8_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_horiz_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_horiz)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_horiz_c(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+void vpx_highbd_convolve8_horiz_avx2(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_horiz)(const uint16_t* src,
+                                               ptrdiff_t src_stride,
+                                               uint16_t* dst,
+                                               ptrdiff_t dst_stride,
+                                               const int16_t* filter_x,
+                                               int x_step_q4,
+                                               const int16_t* filter_y,
+                                               int y_step_q4,
+                                               int w,
+                                               int h,
+                                               int bps);
 
-void vpx_highbd_convolve8_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_vert_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_vert)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_vert_c(const uint16_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint16_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h,
+                                 int bps);
+void vpx_highbd_convolve8_vert_avx2(const uint16_t* src,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst,
+                                    ptrdiff_t dst_stride,
+                                    const int16_t* filter_x,
+                                    int x_step_q4,
+                                    const int16_t* filter_y,
+                                    int y_step_q4,
+                                    int w,
+                                    int h,
+                                    int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_vert)(const uint16_t* src,
+                                              ptrdiff_t src_stride,
+                                              uint16_t* dst,
+                                              ptrdiff_t dst_stride,
+                                              const int16_t* filter_x,
+                                              int x_step_q4,
+                                              const int16_t* filter_y,
+                                              int y_step_q4,
+                                              int w,
+                                              int h,
+                                              int bps);
 
-void vpx_highbd_convolve_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_avg_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_avg_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve_avg)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_avg_c(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+void vpx_highbd_convolve_avg_sse2(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+void vpx_highbd_convolve_avg_avx2(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve_avg)(const uint16_t* src,
+                                            ptrdiff_t src_stride,
+                                            uint16_t* dst,
+                                            ptrdiff_t dst_stride,
+                                            const int16_t* filter_x,
+                                            int x_step_q4,
+                                            const int16_t* filter_y,
+                                            int y_step_q4,
+                                            int w,
+                                            int h,
+                                            int bps);
 
-void vpx_highbd_convolve_copy_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_copy_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_copy_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve_copy)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_copy_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
+void vpx_highbd_convolve_copy_sse2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+void vpx_highbd_convolve_copy_avx2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve_copy)(const uint16_t* src,
+                                             ptrdiff_t src_stride,
+                                             uint16_t* dst,
+                                             ptrdiff_t dst_stride,
+                                             const int16_t* filter_x,
+                                             int x_step_q4,
+                                             const int16_t* filter_y,
+                                             int y_step_q4,
+                                             int w,
+                                             int h,
+                                             int bps);
 
-void vpx_highbd_d117_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_16x16 vpx_highbd_d117_predictor_16x16_c
 
-void vpx_highbd_d117_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_32x32 vpx_highbd_d117_predictor_32x32_c
 
-void vpx_highbd_d117_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_4x4 vpx_highbd_d117_predictor_4x4_c
 
-void vpx_highbd_d117_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_8x8 vpx_highbd_d117_predictor_8x8_c
 
-void vpx_highbd_d135_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_16x16 vpx_highbd_d135_predictor_16x16_c
 
-void vpx_highbd_d135_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_32x32 vpx_highbd_d135_predictor_32x32_c
 
-void vpx_highbd_d135_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_4x4 vpx_highbd_d135_predictor_4x4_c
 
-void vpx_highbd_d135_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_8x8 vpx_highbd_d135_predictor_8x8_c
 
-void vpx_highbd_d153_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_16x16 vpx_highbd_d153_predictor_16x16_c
 
-void vpx_highbd_d153_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_32x32 vpx_highbd_d153_predictor_32x32_c
 
-void vpx_highbd_d153_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_4x4 vpx_highbd_d153_predictor_4x4_c
 
-void vpx_highbd_d153_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_8x8 vpx_highbd_d153_predictor_8x8_c
 
-void vpx_highbd_d207_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_16x16 vpx_highbd_d207_predictor_16x16_c
 
-void vpx_highbd_d207_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_32x32 vpx_highbd_d207_predictor_32x32_c
 
-void vpx_highbd_d207_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_4x4 vpx_highbd_d207_predictor_4x4_c
 
-void vpx_highbd_d207_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_8x8 vpx_highbd_d207_predictor_8x8_c
 
-void vpx_highbd_d45_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_16x16 vpx_highbd_d45_predictor_16x16_c
 
-void vpx_highbd_d45_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_32x32 vpx_highbd_d45_predictor_32x32_c
 
-void vpx_highbd_d45_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_4x4 vpx_highbd_d45_predictor_4x4_c
 
-void vpx_highbd_d45_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_8x8 vpx_highbd_d45_predictor_8x8_c
 
-void vpx_highbd_d63_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_16x16 vpx_highbd_d63_predictor_16x16_c
 
-void vpx_highbd_d63_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_32x32 vpx_highbd_d63_predictor_32x32_c
 
-void vpx_highbd_d63_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_4x4 vpx_highbd_d63_predictor_4x4_c
 
-void vpx_highbd_d63_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_8x8 vpx_highbd_d63_predictor_8x8_c
 
-void vpx_highbd_dc_128_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_16x16 vpx_highbd_dc_128_predictor_16x16_c
 
-void vpx_highbd_dc_128_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_32x32 vpx_highbd_dc_128_predictor_32x32_c
 
-void vpx_highbd_dc_128_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_4x4 vpx_highbd_dc_128_predictor_4x4_c
 
-void vpx_highbd_dc_128_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_8x8 vpx_highbd_dc_128_predictor_8x8_c
 
-void vpx_highbd_dc_left_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_16x16_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_16x16 vpx_highbd_dc_left_predictor_16x16_c
 
-void vpx_highbd_dc_left_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_32x32_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_32x32 vpx_highbd_dc_left_predictor_32x32_c
 
-void vpx_highbd_dc_left_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_4x4_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_4x4 vpx_highbd_dc_left_predictor_4x4_c
 
-void vpx_highbd_dc_left_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_8x8_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_8x8 vpx_highbd_dc_left_predictor_8x8_c
 
-void vpx_highbd_dc_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_dc_predictor_16x16)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_dc_predictor_16x16_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
+RTCD_EXTERN void (*vpx_highbd_dc_predictor_16x16)(uint16_t* dst,
+                                                  ptrdiff_t y_stride,
+                                                  const uint16_t* above,
+                                                  const uint16_t* left,
+                                                  int bd);
 
-void vpx_highbd_dc_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_dc_predictor_32x32)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_dc_predictor_32x32_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
+RTCD_EXTERN void (*vpx_highbd_dc_predictor_32x32)(uint16_t* dst,
+                                                  ptrdiff_t y_stride,
+                                                  const uint16_t* above,
+                                                  const uint16_t* left,
+                                                  int bd);
 
-void vpx_highbd_dc_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_dc_predictor_4x4)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_dc_predictor_4x4_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_dc_predictor_4x4)(uint16_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint16_t* above,
+                                                const uint16_t* left,
+                                                int bd);
 
-void vpx_highbd_dc_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_dc_predictor_8x8)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_dc_predictor_8x8_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_dc_predictor_8x8)(uint16_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint16_t* above,
+                                                const uint16_t* left,
+                                                int bd);
 
-void vpx_highbd_dc_top_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_16x16 vpx_highbd_dc_top_predictor_16x16_c
 
-void vpx_highbd_dc_top_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_32x32 vpx_highbd_dc_top_predictor_32x32_c
 
-void vpx_highbd_dc_top_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_4x4 vpx_highbd_dc_top_predictor_4x4_c
 
-void vpx_highbd_dc_top_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_8x8 vpx_highbd_dc_top_predictor_8x8_c
 
-void vpx_highbd_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct16x16_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct16x16)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
+void vpx_highbd_fdct16x16_sse2(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct16x16)(const int16_t* input,
+                                         tran_low_t* output,
+                                         int stride);
 
-void vpx_highbd_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct16x16_1 vpx_highbd_fdct16x16_1_c
 
-void vpx_highbd_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct32x32_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct32x32)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
+void vpx_highbd_fdct32x32_sse2(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct32x32)(const int16_t* input,
+                                         tran_low_t* output,
+                                         int stride);
 
-void vpx_highbd_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct32x32_1 vpx_highbd_fdct32x32_1_c
 
-void vpx_highbd_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct32x32_rd_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct32x32_rd)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_rd_c(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
+void vpx_highbd_fdct32x32_rd_sse2(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct32x32_rd)(const int16_t* input,
+                                            tran_low_t* output,
+                                            int stride);
 
-void vpx_highbd_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct4x4)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_highbd_fdct4x4_sse2(const int16_t* input,
+                             tran_low_t* output,
+                             int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct4x4)(const int16_t* input,
+                                       tran_low_t* output,
+                                       int stride);
 
-void vpx_highbd_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct8x8_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct8x8)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_highbd_fdct8x8_sse2(const int16_t* input,
+                             tran_low_t* output,
+                             int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct8x8)(const int16_t* input,
+                                       tran_low_t* output,
+                                       int stride);
 
-void vpx_highbd_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_1_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
 #define vpx_highbd_fdct8x8_1 vpx_highbd_fdct8x8_1_c
 
-void vpx_highbd_h_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_16x16 vpx_highbd_h_predictor_16x16_c
 
-void vpx_highbd_h_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_32x32 vpx_highbd_h_predictor_32x32_c
 
-void vpx_highbd_h_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_4x4 vpx_highbd_h_predictor_4x4_c
 
-void vpx_highbd_h_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_8x8 vpx_highbd_h_predictor_8x8_c
 
-void vpx_highbd_idct16x16_10_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_10_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct16x16_10_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_10_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+void vpx_highbd_idct16x16_10_add_sse2(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct16x16_10_add)(const tran_low_t* input,
+                                                uint16_t* dest,
+                                                int stride,
+                                                int bd);
 
-void vpx_highbd_idct16x16_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct16x16_1_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
+void vpx_highbd_idct16x16_1_add_sse2(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_idct16x16_1_add)(const tran_low_t* input,
+                                               uint16_t* dest,
+                                               int stride,
+                                               int bd);
 
-void vpx_highbd_idct16x16_256_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct16x16_256_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_256_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t* input,
+                                       uint16_t* dest,
+                                       int stride,
+                                       int bd);
+RTCD_EXTERN void (*vpx_highbd_idct16x16_256_add)(const tran_low_t* input,
+                                                 uint16_t* dest,
+                                                 int stride,
+                                                 int bd);
 
-void vpx_highbd_idct16x16_38_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct16x16_38_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_38_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+void vpx_highbd_idct16x16_38_add_sse2(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct16x16_38_add)(const tran_low_t* input,
+                                                uint16_t* dest,
+                                                int stride,
+                                                int bd);
 
-void vpx_highbd_idct32x32_1024_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1024_add_c(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
 #define vpx_highbd_idct32x32_1024_add vpx_highbd_idct32x32_1024_add_c
 
-void vpx_highbd_idct32x32_135_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_135_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
 #define vpx_highbd_idct32x32_135_add vpx_highbd_idct32x32_135_add_c
 
-void vpx_highbd_idct32x32_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct32x32_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct32x32_1_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
+void vpx_highbd_idct32x32_1_add_sse2(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_idct32x32_1_add)(const tran_low_t* input,
+                                               uint16_t* dest,
+                                               int stride,
+                                               int bd);
 
-void vpx_highbd_idct32x32_34_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_34_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct32x32_34_add vpx_highbd_idct32x32_34_add_c
 
-void vpx_highbd_idct4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_16_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_16_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct4x4_16_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct4x4_16_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct4x4_16_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct4x4_16_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_idct4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct4x4_1_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
+void vpx_highbd_idct4x4_1_add_sse2(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+RTCD_EXTERN void (*vpx_highbd_idct4x4_1_add)(const tran_low_t* input,
+                                             uint16_t* dest,
+                                             int stride,
+                                             int bd);
 
-void vpx_highbd_idct8x8_12_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_12_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_12_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_12_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_12_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct8x8_12_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct8x8_12_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_12_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_idct8x8_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_1_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
+void vpx_highbd_idct8x8_1_add_sse2(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_1_add)(const tran_low_t* input,
+                                             uint16_t* dest,
+                                             int stride,
+                                             int bd);
 
-void vpx_highbd_idct8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_64_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_64_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_64_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_64_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct8x8_64_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct8x8_64_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_64_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_iwht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
 #define vpx_highbd_iwht4x4_16_add vpx_highbd_iwht4x4_16_add_c
 
-void vpx_highbd_iwht4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
 #define vpx_highbd_iwht4x4_1_add vpx_highbd_iwht4x4_1_add_c
 
-void vpx_highbd_lpf_horizontal_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_16_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_16)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_c(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
+void vpx_highbd_lpf_horizontal_16_sse2(uint16_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh,
+                                       int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_16)(uint16_t* s,
+                                                 int pitch,
+                                                 const uint8_t* blimit,
+                                                 const uint8_t* limit,
+                                                 const uint8_t* thresh,
+                                                 int bd);
 
-void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_16_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_16_dual)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh,
+                                         int bd);
+void vpx_highbd_lpf_horizontal_16_dual_sse2(uint16_t* s,
+                                            int pitch,
+                                            const uint8_t* blimit,
+                                            const uint8_t* limit,
+                                            const uint8_t* thresh,
+                                            int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_16_dual)(uint16_t* s,
+                                                      int pitch,
+                                                      const uint8_t* blimit,
+                                                      const uint8_t* limit,
+                                                      const uint8_t* thresh,
+                                                      int bd);
 
-void vpx_highbd_lpf_horizontal_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_4_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_4)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_4_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
+void vpx_highbd_lpf_horizontal_4_sse2(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit,
+                                      const uint8_t* limit,
+                                      const uint8_t* thresh,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_4)(uint16_t* s,
+                                                int pitch,
+                                                const uint8_t* blimit,
+                                                const uint8_t* limit,
+                                                const uint8_t* thresh,
+                                                int bd);
 
-void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_horizontal_4_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_4_dual)(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
+void vpx_highbd_lpf_horizontal_4_dual_sse2(uint16_t* s,
+                                           int pitch,
+                                           const uint8_t* blimit0,
+                                           const uint8_t* limit0,
+                                           const uint8_t* thresh0,
+                                           const uint8_t* blimit1,
+                                           const uint8_t* limit1,
+                                           const uint8_t* thresh1,
+                                           int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_4_dual)(uint16_t* s,
+                                                     int pitch,
+                                                     const uint8_t* blimit0,
+                                                     const uint8_t* limit0,
+                                                     const uint8_t* thresh0,
+                                                     const uint8_t* blimit1,
+                                                     const uint8_t* limit1,
+                                                     const uint8_t* thresh1,
+                                                     int bd);
 
-void vpx_highbd_lpf_horizontal_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_8_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_8)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_8_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
+void vpx_highbd_lpf_horizontal_8_sse2(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit,
+                                      const uint8_t* limit,
+                                      const uint8_t* thresh,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_8)(uint16_t* s,
+                                                int pitch,
+                                                const uint8_t* blimit,
+                                                const uint8_t* limit,
+                                                const uint8_t* thresh,
+                                                int bd);
 
-void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_horizontal_8_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_8_dual)(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
+void vpx_highbd_lpf_horizontal_8_dual_sse2(uint16_t* s,
+                                           int pitch,
+                                           const uint8_t* blimit0,
+                                           const uint8_t* limit0,
+                                           const uint8_t* thresh0,
+                                           const uint8_t* blimit1,
+                                           const uint8_t* limit1,
+                                           const uint8_t* thresh1,
+                                           int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_8_dual)(uint16_t* s,
+                                                     int pitch,
+                                                     const uint8_t* blimit0,
+                                                     const uint8_t* limit0,
+                                                     const uint8_t* thresh0,
+                                                     const uint8_t* blimit1,
+                                                     const uint8_t* limit1,
+                                                     const uint8_t* thresh1,
+                                                     int bd);
 
-void vpx_highbd_lpf_vertical_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_16_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_16)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_c(uint16_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh,
+                                  int bd);
+void vpx_highbd_lpf_vertical_16_sse2(uint16_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_16)(uint16_t* s,
+                                               int pitch,
+                                               const uint8_t* blimit,
+                                               const uint8_t* limit,
+                                               const uint8_t* thresh,
+                                               int bd);
 
-void vpx_highbd_lpf_vertical_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_16_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_16_dual)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_dual_c(uint16_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh,
+                                       int bd);
+void vpx_highbd_lpf_vertical_16_dual_sse2(uint16_t* s,
+                                          int pitch,
+                                          const uint8_t* blimit,
+                                          const uint8_t* limit,
+                                          const uint8_t* thresh,
+                                          int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_16_dual)(uint16_t* s,
+                                                    int pitch,
+                                                    const uint8_t* blimit,
+                                                    const uint8_t* limit,
+                                                    const uint8_t* thresh,
+                                                    int bd);
 
-void vpx_highbd_lpf_vertical_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_4_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_4)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_4_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
+void vpx_highbd_lpf_vertical_4_sse2(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_4)(uint16_t* s,
+                                              int pitch,
+                                              const uint8_t* blimit,
+                                              const uint8_t* limit,
+                                              const uint8_t* thresh,
+                                              int bd);
 
-void vpx_highbd_lpf_vertical_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_vertical_4_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_4_dual)(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_4_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
+void vpx_highbd_lpf_vertical_4_dual_sse2(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit0,
+                                         const uint8_t* limit0,
+                                         const uint8_t* thresh0,
+                                         const uint8_t* blimit1,
+                                         const uint8_t* limit1,
+                                         const uint8_t* thresh1,
+                                         int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_4_dual)(uint16_t* s,
+                                                   int pitch,
+                                                   const uint8_t* blimit0,
+                                                   const uint8_t* limit0,
+                                                   const uint8_t* thresh0,
+                                                   const uint8_t* blimit1,
+                                                   const uint8_t* limit1,
+                                                   const uint8_t* thresh1,
+                                                   int bd);
 
-void vpx_highbd_lpf_vertical_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_8_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_8)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_8_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
+void vpx_highbd_lpf_vertical_8_sse2(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_8)(uint16_t* s,
+                                              int pitch,
+                                              const uint8_t* blimit,
+                                              const uint8_t* limit,
+                                              const uint8_t* thresh,
+                                              int bd);
 
-void vpx_highbd_lpf_vertical_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_vertical_8_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_8_dual)(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_8_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
+void vpx_highbd_lpf_vertical_8_dual_sse2(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit0,
+                                         const uint8_t* limit0,
+                                         const uint8_t* thresh0,
+                                         const uint8_t* blimit1,
+                                         const uint8_t* limit1,
+                                         const uint8_t* thresh1,
+                                         int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_8_dual)(uint16_t* s,
+                                                   int pitch,
+                                                   const uint8_t* blimit0,
+                                                   const uint8_t* limit0,
+                                                   const uint8_t* thresh0,
+                                                   const uint8_t* blimit1,
+                                                   const uint8_t* limit1,
+                                                   const uint8_t* thresh1,
+                                                   int bd);
 
-void vpx_highbd_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_highbd_minmax_8x8_c(const uint8_t* s,
+                             int p,
+                             const uint8_t* d,
+                             int dp,
+                             int* min,
+                             int* max);
 #define vpx_highbd_minmax_8x8 vpx_highbd_minmax_8x8_c
 
-void vpx_highbd_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_highbd_quantize_b_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_highbd_quantize_b)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* zbin_ptr,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             const int16_t* quant_shift_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+void vpx_highbd_quantize_b_sse2(const tran_low_t* coeff_ptr,
+                                intptr_t n_coeffs,
+                                int skip_block,
+                                const int16_t* zbin_ptr,
+                                const int16_t* round_ptr,
+                                const int16_t* quant_ptr,
+                                const int16_t* quant_shift_ptr,
+                                tran_low_t* qcoeff_ptr,
+                                tran_low_t* dqcoeff_ptr,
+                                const int16_t* dequant_ptr,
+                                uint16_t* eob_ptr,
+                                const int16_t* scan,
+                                const int16_t* iscan);
+RTCD_EXTERN void (*vpx_highbd_quantize_b)(const tran_low_t* coeff_ptr,
+                                          intptr_t n_coeffs,
+                                          int skip_block,
+                                          const int16_t* zbin_ptr,
+                                          const int16_t* round_ptr,
+                                          const int16_t* quant_ptr,
+                                          const int16_t* quant_shift_ptr,
+                                          tran_low_t* qcoeff_ptr,
+                                          tran_low_t* dqcoeff_ptr,
+                                          const int16_t* dequant_ptr,
+                                          uint16_t* eob_ptr,
+                                          const int16_t* scan,
+                                          const int16_t* iscan);
 
-void vpx_highbd_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_highbd_quantize_b_32x32_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_highbd_quantize_b_32x32)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
+void vpx_highbd_quantize_b_32x32_sse2(const tran_low_t* coeff_ptr,
+                                      intptr_t n_coeffs,
+                                      int skip_block,
+                                      const int16_t* zbin_ptr,
+                                      const int16_t* round_ptr,
+                                      const int16_t* quant_ptr,
+                                      const int16_t* quant_shift_ptr,
+                                      tran_low_t* qcoeff_ptr,
+                                      tran_low_t* dqcoeff_ptr,
+                                      const int16_t* dequant_ptr,
+                                      uint16_t* eob_ptr,
+                                      const int16_t* scan,
+                                      const int16_t* iscan);
+RTCD_EXTERN void (*vpx_highbd_quantize_b_32x32)(const tran_low_t* coeff_ptr,
+                                                intptr_t n_coeffs,
+                                                int skip_block,
+                                                const int16_t* zbin_ptr,
+                                                const int16_t* round_ptr,
+                                                const int16_t* quant_ptr,
+                                                const int16_t* quant_shift_ptr,
+                                                tran_low_t* qcoeff_ptr,
+                                                tran_low_t* dqcoeff_ptr,
+                                                const int16_t* dequant_ptr,
+                                                uint16_t* eob_ptr,
+                                                const int16_t* scan,
+                                                const int16_t* iscan);
 
-unsigned int vpx_highbd_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad16x16_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x16)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x16_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x16_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad16x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad16x16x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad16x16x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad16x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x32)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x32_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad16x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad16x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad16x32x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x8_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int vpx_highbd_sad16x8_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x8)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
 
-unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x8_avg_sse2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x8_avg)(const uint8_t* src_ptr,
+                                                   int src_stride,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   const uint8_t* second_pred);
 
-void vpx_highbd_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad16x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x8x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void vpx_highbd_sad16x8x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad16x8x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x16_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x16)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x16_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x16_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad32x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x16x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad32x16x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x32)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x32_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad32x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad32x32x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x64)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x64_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x64_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad32x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad32x64x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x4 vpx_highbd_sad4x4_c
 
-unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x4_avg vpx_highbd_sad4x4_avg_c
 
-void vpx_highbd_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad4x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad4x4x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad4x4x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad4x4x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x8 vpx_highbd_sad4x8_c
 
-unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x8_avg vpx_highbd_sad4x8_avg_c
 
-void vpx_highbd_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad4x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad4x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad4x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad4x8x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad64x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad64x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad64x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad64x32)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad64x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad64x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad64x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad64x32_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad64x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad64x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad64x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad64x32x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad64x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad64x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad64x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad64x64)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad64x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad64x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad64x64_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad64x64_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad64x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad64x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad64x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad64x64x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int vpx_highbd_sad8x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x16)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
 
-unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x16_avg_sse2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x16_avg)(const uint8_t* src_ptr,
+                                                   int src_stride,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   const uint8_t* second_pred);
 
-void vpx_highbd_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad8x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void vpx_highbd_sad8x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad8x16x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x4)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int vpx_highbd_sad8x4_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x4)(const uint8_t* src_ptr,
+                                              int src_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride);
 
-unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x4_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x4_avg_sse2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x4_avg)(const uint8_t* src_ptr,
+                                                  int src_stride,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  const uint8_t* second_pred);
 
-void vpx_highbd_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad8x4x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad8x4x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad8x4x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int vpx_highbd_sad8x8_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x8)(const uint8_t* src_ptr,
+                                              int src_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride);
 
-unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x8_avg_sse2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x8_avg)(const uint8_t* src_ptr,
+                                                  int src_stride,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  const uint8_t* second_pred);
 
-void vpx_highbd_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad8x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad8x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad8x8x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
 
-void vpx_highbd_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride, int bd);
+void vpx_highbd_subtract_block_c(int rows,
+                                 int cols,
+                                 int16_t* diff_ptr,
+                                 ptrdiff_t diff_stride,
+                                 const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 const uint8_t* pred_ptr,
+                                 ptrdiff_t pred_stride,
+                                 int bd);
 #define vpx_highbd_subtract_block vpx_highbd_subtract_block_c
 
-void vpx_highbd_tm_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_tm_predictor_16x16)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_tm_predictor_16x16_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
+RTCD_EXTERN void (*vpx_highbd_tm_predictor_16x16)(uint16_t* dst,
+                                                  ptrdiff_t y_stride,
+                                                  const uint16_t* above,
+                                                  const uint16_t* left,
+                                                  int bd);
 
-void vpx_highbd_tm_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_tm_predictor_32x32)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_tm_predictor_32x32_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
+RTCD_EXTERN void (*vpx_highbd_tm_predictor_32x32)(uint16_t* dst,
+                                                  ptrdiff_t y_stride,
+                                                  const uint16_t* above,
+                                                  const uint16_t* left,
+                                                  int bd);
 
-void vpx_highbd_tm_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_tm_predictor_4x4)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_tm_predictor_4x4_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_tm_predictor_4x4)(uint16_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint16_t* above,
+                                                const uint16_t* left,
+                                                int bd);
 
-void vpx_highbd_tm_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_tm_predictor_8x8)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_tm_predictor_8x8_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_tm_predictor_8x8)(uint16_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint16_t* above,
+                                                const uint16_t* left,
+                                                int bd);
 
-void vpx_highbd_v_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_v_predictor_16x16)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
+void vpx_highbd_v_predictor_16x16_sse2(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
+RTCD_EXTERN void (*vpx_highbd_v_predictor_16x16)(uint16_t* dst,
+                                                 ptrdiff_t y_stride,
+                                                 const uint16_t* above,
+                                                 const uint16_t* left,
+                                                 int bd);
 
-void vpx_highbd_v_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_v_predictor_32x32)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
+void vpx_highbd_v_predictor_32x32_sse2(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
+RTCD_EXTERN void (*vpx_highbd_v_predictor_32x32)(uint16_t* dst,
+                                                 ptrdiff_t y_stride,
+                                                 const uint16_t* above,
+                                                 const uint16_t* left,
+                                                 int bd);
 
-void vpx_highbd_v_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_v_predictor_4x4)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
+void vpx_highbd_v_predictor_4x4_sse2(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_v_predictor_4x4)(uint16_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint16_t* above,
+                                               const uint16_t* left,
+                                               int bd);
 
-void vpx_highbd_v_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_v_predictor_8x8)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
+void vpx_highbd_v_predictor_8x8_sse2(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_v_predictor_8x8)(uint16_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint16_t* above,
+                                               const uint16_t* left,
+                                               int bd);
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_10_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_10_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_10_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+RTCD_EXTERN void (*vpx_idct16x16_10_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_1_add_sse2(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+RTCD_EXTERN void (*vpx_idct16x16_1_add)(const tran_low_t* input,
+                                        uint8_t* dest,
+                                        int stride);
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_256_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_256_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct16x16_256_add_sse2(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
+RTCD_EXTERN void (*vpx_idct16x16_256_add)(const tran_low_t* input,
+                                          uint8_t* dest,
+                                          int stride);
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_38_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_38_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_38_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+RTCD_EXTERN void (*vpx_idct16x16_38_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_1024_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+void vpx_idct32x32_1024_add_sse2(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+RTCD_EXTERN void (*vpx_idct32x32_1024_add)(const tran_low_t* input,
+                                           uint8_t* dest,
+                                           int stride);
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_135_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_135_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct32x32_1024_add_sse2(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+void vpx_idct32x32_135_add_ssse3(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+RTCD_EXTERN void (*vpx_idct32x32_135_add)(const tran_low_t* input,
+                                          uint8_t* dest,
+                                          int stride);
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_1_add_sse2(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+RTCD_EXTERN void (*vpx_idct32x32_1_add)(const tran_low_t* input,
+                                        uint8_t* dest,
+                                        int stride);
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_34_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_34_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+void vpx_idct32x32_34_add_ssse3(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
+RTCD_EXTERN void (*vpx_idct32x32_34_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct4x4_16_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_16_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+RTCD_EXTERN void (*vpx_idct4x4_16_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct4x4_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_1_add_sse2(const tran_low_t* input, uint8_t* dest, int stride);
+RTCD_EXTERN void (*vpx_idct4x4_1_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride);
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_12_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_12_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct8x8_12_add_ssse3(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+RTCD_EXTERN void (*vpx_idct8x8_12_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_1_add_sse2(const tran_low_t* input, uint8_t* dest, int stride);
+RTCD_EXTERN void (*vpx_idct8x8_1_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride);
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_64_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_64_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_64_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+RTCD_EXTERN void (*vpx_idct8x8_64_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
-int16_t vpx_int_pro_col_sse2(const uint8_t *ref, const int width);
-RTCD_EXTERN int16_t (*vpx_int_pro_col)(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
+int16_t vpx_int_pro_col_sse2(const uint8_t* ref, const int width);
+RTCD_EXTERN int16_t (*vpx_int_pro_col)(const uint8_t* ref, const int width);
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-void vpx_int_pro_row_sse2(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-RTCD_EXTERN void (*vpx_int_pro_row)(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
+void vpx_int_pro_row_sse2(int16_t* hbuf,
+                          const uint8_t* ref,
+                          const int ref_stride,
+                          const int height);
+RTCD_EXTERN void (*vpx_int_pro_row)(int16_t* hbuf,
+                                    const uint8_t* ref,
+                                    const int ref_stride,
+                                    const int height);
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_iwht4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_iwht4x4_16_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_iwht4x4_16_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+RTCD_EXTERN void (*vpx_iwht4x4_16_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_avx2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_16)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+void vpx_lpf_horizontal_16_sse2(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_horizontal_16_avx2(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_16)(uint8_t* s,
+                                          int pitch,
+                                          const uint8_t* blimit,
+                                          const uint8_t* limit,
+                                          const uint8_t* thresh);
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_avx2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_16_dual)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_sse2(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_avx2(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_16_dual)(uint8_t* s,
+                                               int pitch,
+                                               const uint8_t* blimit,
+                                               const uint8_t* limit,
+                                               const uint8_t* thresh);
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_4_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_4)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_4_sse2(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_4)(uint8_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh);
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_4_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_horizontal_4_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_4_dual_sse2(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_horizontal_4_dual)(uint8_t* s,
+                                              int pitch,
+                                              const uint8_t* blimit0,
+                                              const uint8_t* limit0,
+                                              const uint8_t* thresh0,
+                                              const uint8_t* blimit1,
+                                              const uint8_t* limit1,
+                                              const uint8_t* thresh1);
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_8_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_8)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_8_sse2(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_8)(uint8_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh);
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_8_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_horizontal_8_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_8_dual_sse2(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_horizontal_8_dual)(uint8_t* s,
+                                              int pitch,
+                                              const uint8_t* blimit0,
+                                              const uint8_t* limit0,
+                                              const uint8_t* thresh0,
+                                              const uint8_t* blimit1,
+                                              const uint8_t* limit1,
+                                              const uint8_t* thresh1);
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_16)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
+void vpx_lpf_vertical_16_sse2(uint8_t* s,
+                              int pitch,
+                              const uint8_t* blimit,
+                              const uint8_t* limit,
+                              const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_16)(uint8_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit,
+                                        const uint8_t* limit,
+                                        const uint8_t* thresh);
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_16_dual)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_vertical_16_dual_sse2(uint8_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_16_dual)(uint8_t* s,
+                                             int pitch,
+                                             const uint8_t* blimit,
+                                             const uint8_t* limit,
+                                             const uint8_t* thresh);
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_4_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_4)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_4_sse2(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_4)(uint8_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh);
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_4_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_vertical_4_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_4_dual_sse2(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_vertical_4_dual)(uint8_t* s,
+                                            int pitch,
+                                            const uint8_t* blimit0,
+                                            const uint8_t* limit0,
+                                            const uint8_t* thresh0,
+                                            const uint8_t* blimit1,
+                                            const uint8_t* limit1,
+                                            const uint8_t* thresh1);
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_8_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_8)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_8_sse2(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_8)(uint8_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh);
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_8_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_vertical_8_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_8_dual_sse2(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_vertical_8_dual)(uint8_t* s,
+                                            int pitch,
+                                            const uint8_t* blimit0,
+                                            const uint8_t* limit0,
+                                            const uint8_t* thresh0,
+                                            const uint8_t* blimit1,
+                                            const uint8_t* limit1,
+                                            const uint8_t* thresh1);
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_across_ip_sse2(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-RTCD_EXTERN void (*vpx_mbpost_proc_across_ip)(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
+void vpx_mbpost_proc_across_ip_sse2(unsigned char* dst,
+                                    int pitch,
+                                    int rows,
+                                    int cols,
+                                    int flimit);
+RTCD_EXTERN void (*vpx_mbpost_proc_across_ip)(unsigned char* dst,
+                                              int pitch,
+                                              int rows,
+                                              int cols,
+                                              int flimit);
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_down_sse2(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-RTCD_EXTERN void (*vpx_mbpost_proc_down)(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
+void vpx_mbpost_proc_down_sse2(unsigned char* dst,
+                               int pitch,
+                               int rows,
+                               int cols,
+                               int flimit);
+RTCD_EXTERN void (*vpx_mbpost_proc_down)(unsigned char* dst,
+                                         int pitch,
+                                         int rows,
+                                         int cols,
+                                         int flimit);
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-void vpx_minmax_8x8_sse2(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-RTCD_EXTERN void (*vpx_minmax_8x8)(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
+void vpx_minmax_8x8_sse2(const uint8_t* s,
+                         int p,
+                         const uint8_t* d,
+                         int dp,
+                         int* min,
+                         int* max);
+RTCD_EXTERN void (*vpx_minmax_8x8)(const uint8_t* s,
+                                   int p,
+                                   const uint8_t* d,
+                                   int dp,
+                                   int* min,
+                                   int* max);
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_avx2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
+unsigned int vpx_mse16x16_sse2(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
+unsigned int vpx_mse16x16_avx2(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse16x16)(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse16x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
+unsigned int vpx_mse16x8_sse2(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int recon_stride,
+                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse16x8)(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int recon_stride,
+                                        unsigned int* sse);
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse8x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse8x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
+unsigned int vpx_mse8x16_sse2(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int recon_stride,
+                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse8x16)(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int recon_stride,
+                                        unsigned int* sse);
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse8x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
+unsigned int vpx_mse8x8_sse2(const uint8_t* src_ptr,
+                             int source_stride,
+                             const uint8_t* ref_ptr,
+                             int recon_stride,
+                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse8x8)(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
-void vpx_plane_add_noise_sse2(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
-RTCD_EXTERN void (*vpx_plane_add_noise)(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
+void vpx_plane_add_noise_sse2(uint8_t* start,
+                              const int8_t* noise,
+                              int blackclamp,
+                              int whiteclamp,
+                              int width,
+                              int height,
+                              int pitch);
+RTCD_EXTERN void (*vpx_plane_add_noise)(uint8_t* start,
+                                        const int8_t* noise,
+                                        int blackclamp,
+                                        int whiteclamp,
+                                        int width,
+                                        int height,
+                                        int pitch);
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-void vpx_post_proc_down_and_across_mb_row_sse2(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-RTCD_EXTERN void (*vpx_post_proc_down_and_across_mb_row)(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+void vpx_post_proc_down_and_across_mb_row_sse2(unsigned char* src,
+                                               unsigned char* dst,
+                                               int src_pitch,
+                                               int dst_pitch,
+                                               int cols,
+                                               unsigned char* flimits,
+                                               int size);
+RTCD_EXTERN void (*vpx_post_proc_down_and_across_mb_row)(unsigned char* src,
+                                                         unsigned char* dst,
+                                                         int src_pitch,
+                                                         int dst_pitch,
+                                                         int cols,
+                                                         unsigned char* flimits,
+                                                         int size);
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_quantize_b)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
+void vpx_quantize_b_sse2(const tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* zbin_ptr,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         const int16_t* quant_shift_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+RTCD_EXTERN void (*vpx_quantize_b)(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vpx_quantize_b_32x32 vpx_quantize_b_32x32_c
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad16x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x16_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad16x16)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad16x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x16_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad16x16_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x3_ssse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x16x3_sse3(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+void vpx_sad16x16x3_ssse3(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x3)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x16x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x16x8_sse4_1(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride,
+                           uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x8)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad16x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad16x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad16x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad16x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad16x8_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad16x8)(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad16x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad16x8_avg_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad16x8_avg)(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            const uint8_t* second_pred);
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x3_ssse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad16x8x3_sse3(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        uint32_t* sad_array);
+void vpx_sad16x8x3_ssse3(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x3)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x8x4d_sse2(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x4d)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad16x8x8_sse4_1(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x8)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x16_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x16_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x16)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x16_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x16x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x16x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x32_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+void vpx_sad32x32x4d_avx2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x64_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x64_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x64)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x64_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x64x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x64x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad4x4)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x4_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad4x4)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad4x4_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x4_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad4x4_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad4x4x3_sse3(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x3)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x4x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad4x4x8_sse4_1(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x8)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad4x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x8_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad4x8)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad4x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x8_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad4x8_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x8x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x8x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad64x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad64x32_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad64x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad64x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad64x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad64x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad64x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad64x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x64_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad64x64_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad64x64)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad64x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad64x64_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad64x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x64x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+void vpx_sad64x64x4d_avx2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad64x64x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad8x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad8x16_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad8x16)(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad8x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad8x16_avg_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad8x16_avg)(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            const uint8_t* second_pred);
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x16x3_sse3(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x3)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad8x16x4d_sse2(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x4d)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x16x8_sse4_1(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x8)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad8x4)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x4_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad8x4)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad8x4_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x4_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad8x4_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x4x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x4x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x4x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x8_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad8x8)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad8x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x8_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad8x8_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad8x8x3_sse3(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x3)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x8x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad8x8x8_sse4_1(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x8)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-int vpx_satd_c(const tran_low_t *coeff, int length);
-int vpx_satd_sse2(const tran_low_t *coeff, int length);
-RTCD_EXTERN int (*vpx_satd)(const tran_low_t *coeff, int length);
+int vpx_satd_c(const tran_low_t* coeff, int length);
+int vpx_satd_sse2(const tran_low_t* coeff, int length);
+RTCD_EXTERN int (*vpx_satd)(const tran_low_t* coeff, int length);
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_scaled_2d_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_scaled_2d)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_scaled_2d_ssse3(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+RTCD_EXTERN void (*vpx_scaled_2d)(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_ssse3(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_avx2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_avx2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_ssse3(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x16)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_ssse3(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x8)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x16)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_avx2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x64)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x4)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x8)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_avx2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x64)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_ssse3(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x16)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x4)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x8)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-void vpx_subtract_block_sse2(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-RTCD_EXTERN void (*vpx_subtract_block)(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
+void vpx_subtract_block_sse2(int rows,
+                             int cols,
+                             int16_t* diff_ptr,
+                             ptrdiff_t diff_stride,
+                             const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             const uint8_t* pred_ptr,
+                             ptrdiff_t pred_stride);
+RTCD_EXTERN void (*vpx_subtract_block)(int rows,
+                                       int cols,
+                                       int16_t* diff_ptr,
+                                       ptrdiff_t diff_stride,
+                                       const uint8_t* src_ptr,
+                                       ptrdiff_t src_stride,
+                                       const uint8_t* pred_ptr,
+                                       ptrdiff_t pred_stride);
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
-uint64_t vpx_sum_squares_2d_i16_sse2(const int16_t *src, int stride, int size);
-RTCD_EXTERN uint64_t (*vpx_sum_squares_2d_i16)(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_sse2(const int16_t* src, int stride, int size);
+RTCD_EXTERN uint64_t (*vpx_sum_squares_2d_i16)(const int16_t* src,
+                                               int stride,
+                                               int size);
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_16x16_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_16x16)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_32x32_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_32x32)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_4x4_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_4x4)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_8x8_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_8x8)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_16x16_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_16x16)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_32x32_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_32x32)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_4x4_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_4x4)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_8x8_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_8x8)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x16_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance16x16_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x16)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance16x8_sse2(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x8)(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x16_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance32x16_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x16)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance32x32_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x64_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x64)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance4x4)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x4_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance4x4)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance4x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x8_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance4x8)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance64x32_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance64x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x64_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance64x64_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance64x64)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance8x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance8x16_sse2(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance8x16)(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance8x4)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x4_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance8x4)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance8x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x8_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance8x8)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
-int vpx_vector_var_sse2(const int16_t *ref, const int16_t *src, const int bwl);
-RTCD_EXTERN int (*vpx_vector_var)(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
+int vpx_vector_var_sse2(const int16_t* ref, const int16_t* src, const int bwl);
+RTCD_EXTERN int (*vpx_vector_var)(const int16_t* ref,
+                                  const int16_t* src,
+                                  const int bwl);
 
 void vpx_dsp_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vpx_avg_4x4 = vpx_avg_4x4_c;
-    if (flags & HAS_SSE2) vpx_avg_4x4 = vpx_avg_4x4_sse2;
-    vpx_avg_8x8 = vpx_avg_8x8_c;
-    if (flags & HAS_SSE2) vpx_avg_8x8 = vpx_avg_8x8_sse2;
-    vpx_comp_avg_pred = vpx_comp_avg_pred_c;
-    if (flags & HAS_SSE2) vpx_comp_avg_pred = vpx_comp_avg_pred_sse2;
-    vpx_convolve8 = vpx_convolve8_c;
-    if (flags & HAS_SSE2) vpx_convolve8 = vpx_convolve8_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8 = vpx_convolve8_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8 = vpx_convolve8_avx2;
-    vpx_convolve8_avg = vpx_convolve8_avg_c;
-    if (flags & HAS_SSE2) vpx_convolve8_avg = vpx_convolve8_avg_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg = vpx_convolve8_avg_ssse3;
-    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_c;
-    if (flags & HAS_SSE2) vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_ssse3;
-    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_c;
-    if (flags & HAS_SSE2) vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_ssse3;
-    vpx_convolve8_horiz = vpx_convolve8_horiz_c;
-    if (flags & HAS_SSE2) vpx_convolve8_horiz = vpx_convolve8_horiz_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_horiz = vpx_convolve8_horiz_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8_horiz = vpx_convolve8_horiz_avx2;
-    vpx_convolve8_vert = vpx_convolve8_vert_c;
-    if (flags & HAS_SSE2) vpx_convolve8_vert = vpx_convolve8_vert_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_vert = vpx_convolve8_vert_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8_vert = vpx_convolve8_vert_avx2;
-    vpx_convolve_avg = vpx_convolve_avg_c;
-    if (flags & HAS_SSE2) vpx_convolve_avg = vpx_convolve_avg_sse2;
-    vpx_convolve_copy = vpx_convolve_copy_c;
-    if (flags & HAS_SSE2) vpx_convolve_copy = vpx_convolve_copy_sse2;
-    vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_ssse3;
-    vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_ssse3;
-    vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_ssse3;
-    vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_ssse3;
-    vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_ssse3;
-    vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_ssse3;
-    vpx_d207_predictor_4x4 = vpx_d207_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_d207_predictor_4x4 = vpx_d207_predictor_4x4_sse2;
-    vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_ssse3;
-    vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_ssse3;
-    vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_ssse3;
-    vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_sse2;
-    vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_sse2;
-    vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_ssse3;
-    vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_ssse3;
-    vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_ssse3;
-    vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_ssse3;
-    vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_sse2;
-    vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_sse2;
-    vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_sse2;
-    vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_sse2;
-    vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_sse2;
-    vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_sse2;
-    vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_sse2;
-    vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_sse2;
-    vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_sse2;
-    vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_sse2;
-    vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_sse2;
-    vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_sse2;
-    vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_sse2;
-    vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_sse2;
-    vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_sse2;
-    vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_sse2;
-    vpx_fdct16x16 = vpx_fdct16x16_c;
-    if (flags & HAS_SSE2) vpx_fdct16x16 = vpx_fdct16x16_sse2;
-    vpx_fdct16x16_1 = vpx_fdct16x16_1_c;
-    if (flags & HAS_SSE2) vpx_fdct16x16_1 = vpx_fdct16x16_1_sse2;
-    vpx_fdct32x32 = vpx_fdct32x32_c;
-    if (flags & HAS_SSE2) vpx_fdct32x32 = vpx_fdct32x32_sse2;
-    vpx_fdct32x32_1 = vpx_fdct32x32_1_c;
-    if (flags & HAS_SSE2) vpx_fdct32x32_1 = vpx_fdct32x32_1_sse2;
-    vpx_fdct32x32_rd = vpx_fdct32x32_rd_c;
-    if (flags & HAS_SSE2) vpx_fdct32x32_rd = vpx_fdct32x32_rd_sse2;
-    vpx_fdct4x4 = vpx_fdct4x4_c;
-    if (flags & HAS_SSE2) vpx_fdct4x4 = vpx_fdct4x4_sse2;
-    vpx_fdct4x4_1 = vpx_fdct4x4_1_c;
-    if (flags & HAS_SSE2) vpx_fdct4x4_1 = vpx_fdct4x4_1_sse2;
-    vpx_fdct8x8 = vpx_fdct8x8_c;
-    if (flags & HAS_SSE2) vpx_fdct8x8 = vpx_fdct8x8_sse2;
-    vpx_fdct8x8_1 = vpx_fdct8x8_1_c;
-    if (flags & HAS_SSE2) vpx_fdct8x8_1 = vpx_fdct8x8_1_sse2;
-    vpx_get16x16var = vpx_get16x16var_c;
-    if (flags & HAS_SSE2) vpx_get16x16var = vpx_get16x16var_sse2;
-    if (flags & HAS_AVX2) vpx_get16x16var = vpx_get16x16var_avx2;
-    vpx_get8x8var = vpx_get8x8var_c;
-    if (flags & HAS_SSE2) vpx_get8x8var = vpx_get8x8var_sse2;
-    vpx_get_mb_ss = vpx_get_mb_ss_c;
-    if (flags & HAS_SSE2) vpx_get_mb_ss = vpx_get_mb_ss_sse2;
-    vpx_h_predictor_16x16 = vpx_h_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_h_predictor_16x16 = vpx_h_predictor_16x16_sse2;
-    vpx_h_predictor_32x32 = vpx_h_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_h_predictor_32x32 = vpx_h_predictor_32x32_sse2;
-    vpx_h_predictor_4x4 = vpx_h_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_h_predictor_4x4 = vpx_h_predictor_4x4_sse2;
-    vpx_h_predictor_8x8 = vpx_h_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_h_predictor_8x8 = vpx_h_predictor_8x8_sse2;
-    vpx_hadamard_16x16 = vpx_hadamard_16x16_c;
-    if (flags & HAS_SSE2) vpx_hadamard_16x16 = vpx_hadamard_16x16_sse2;
-    vpx_hadamard_8x8 = vpx_hadamard_8x8_c;
-    if (flags & HAS_SSE2) vpx_hadamard_8x8 = vpx_hadamard_8x8_sse2;
-    vpx_highbd_10_mse16x16 = vpx_highbd_10_mse16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_mse16x16 = vpx_highbd_10_mse16x16_sse2;
-    vpx_highbd_10_mse8x8 = vpx_highbd_10_mse8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_mse8x8 = vpx_highbd_10_mse8x8_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance16x16 = vpx_highbd_10_sub_pixel_avg_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance16x16 = vpx_highbd_10_sub_pixel_avg_variance16x16_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance16x32 = vpx_highbd_10_sub_pixel_avg_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance16x32 = vpx_highbd_10_sub_pixel_avg_variance16x32_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance16x8 = vpx_highbd_10_sub_pixel_avg_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance16x8 = vpx_highbd_10_sub_pixel_avg_variance16x8_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance32x16 = vpx_highbd_10_sub_pixel_avg_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance32x16 = vpx_highbd_10_sub_pixel_avg_variance32x16_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance32x32 = vpx_highbd_10_sub_pixel_avg_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance32x32 = vpx_highbd_10_sub_pixel_avg_variance32x32_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance32x64 = vpx_highbd_10_sub_pixel_avg_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance32x64 = vpx_highbd_10_sub_pixel_avg_variance32x64_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance64x32 = vpx_highbd_10_sub_pixel_avg_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance64x32 = vpx_highbd_10_sub_pixel_avg_variance64x32_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance64x64 = vpx_highbd_10_sub_pixel_avg_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance64x64 = vpx_highbd_10_sub_pixel_avg_variance64x64_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance8x16 = vpx_highbd_10_sub_pixel_avg_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance8x16 = vpx_highbd_10_sub_pixel_avg_variance8x16_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance8x4 = vpx_highbd_10_sub_pixel_avg_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance8x4 = vpx_highbd_10_sub_pixel_avg_variance8x4_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance8x8 = vpx_highbd_10_sub_pixel_avg_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance8x8 = vpx_highbd_10_sub_pixel_avg_variance8x8_sse2;
-    vpx_highbd_10_sub_pixel_variance16x16 = vpx_highbd_10_sub_pixel_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance16x16 = vpx_highbd_10_sub_pixel_variance16x16_sse2;
-    vpx_highbd_10_sub_pixel_variance16x32 = vpx_highbd_10_sub_pixel_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance16x32 = vpx_highbd_10_sub_pixel_variance16x32_sse2;
-    vpx_highbd_10_sub_pixel_variance16x8 = vpx_highbd_10_sub_pixel_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance16x8 = vpx_highbd_10_sub_pixel_variance16x8_sse2;
-    vpx_highbd_10_sub_pixel_variance32x16 = vpx_highbd_10_sub_pixel_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance32x16 = vpx_highbd_10_sub_pixel_variance32x16_sse2;
-    vpx_highbd_10_sub_pixel_variance32x32 = vpx_highbd_10_sub_pixel_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance32x32 = vpx_highbd_10_sub_pixel_variance32x32_sse2;
-    vpx_highbd_10_sub_pixel_variance32x64 = vpx_highbd_10_sub_pixel_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance32x64 = vpx_highbd_10_sub_pixel_variance32x64_sse2;
-    vpx_highbd_10_sub_pixel_variance64x32 = vpx_highbd_10_sub_pixel_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance64x32 = vpx_highbd_10_sub_pixel_variance64x32_sse2;
-    vpx_highbd_10_sub_pixel_variance64x64 = vpx_highbd_10_sub_pixel_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance64x64 = vpx_highbd_10_sub_pixel_variance64x64_sse2;
-    vpx_highbd_10_sub_pixel_variance8x16 = vpx_highbd_10_sub_pixel_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance8x16 = vpx_highbd_10_sub_pixel_variance8x16_sse2;
-    vpx_highbd_10_sub_pixel_variance8x4 = vpx_highbd_10_sub_pixel_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance8x4 = vpx_highbd_10_sub_pixel_variance8x4_sse2;
-    vpx_highbd_10_sub_pixel_variance8x8 = vpx_highbd_10_sub_pixel_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance8x8 = vpx_highbd_10_sub_pixel_variance8x8_sse2;
-    vpx_highbd_10_variance16x16 = vpx_highbd_10_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance16x16 = vpx_highbd_10_variance16x16_sse2;
-    vpx_highbd_10_variance16x32 = vpx_highbd_10_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance16x32 = vpx_highbd_10_variance16x32_sse2;
-    vpx_highbd_10_variance16x8 = vpx_highbd_10_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance16x8 = vpx_highbd_10_variance16x8_sse2;
-    vpx_highbd_10_variance32x16 = vpx_highbd_10_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance32x16 = vpx_highbd_10_variance32x16_sse2;
-    vpx_highbd_10_variance32x32 = vpx_highbd_10_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance32x32 = vpx_highbd_10_variance32x32_sse2;
-    vpx_highbd_10_variance32x64 = vpx_highbd_10_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance32x64 = vpx_highbd_10_variance32x64_sse2;
-    vpx_highbd_10_variance64x32 = vpx_highbd_10_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance64x32 = vpx_highbd_10_variance64x32_sse2;
-    vpx_highbd_10_variance64x64 = vpx_highbd_10_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance64x64 = vpx_highbd_10_variance64x64_sse2;
-    vpx_highbd_10_variance8x16 = vpx_highbd_10_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance8x16 = vpx_highbd_10_variance8x16_sse2;
-    vpx_highbd_10_variance8x8 = vpx_highbd_10_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance8x8 = vpx_highbd_10_variance8x8_sse2;
-    vpx_highbd_12_mse16x16 = vpx_highbd_12_mse16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_mse16x16 = vpx_highbd_12_mse16x16_sse2;
-    vpx_highbd_12_mse8x8 = vpx_highbd_12_mse8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_mse8x8 = vpx_highbd_12_mse8x8_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance16x16 = vpx_highbd_12_sub_pixel_avg_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance16x16 = vpx_highbd_12_sub_pixel_avg_variance16x16_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance16x32 = vpx_highbd_12_sub_pixel_avg_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance16x32 = vpx_highbd_12_sub_pixel_avg_variance16x32_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance16x8 = vpx_highbd_12_sub_pixel_avg_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance16x8 = vpx_highbd_12_sub_pixel_avg_variance16x8_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance32x16 = vpx_highbd_12_sub_pixel_avg_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance32x16 = vpx_highbd_12_sub_pixel_avg_variance32x16_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance32x32 = vpx_highbd_12_sub_pixel_avg_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance32x32 = vpx_highbd_12_sub_pixel_avg_variance32x32_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance32x64 = vpx_highbd_12_sub_pixel_avg_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance32x64 = vpx_highbd_12_sub_pixel_avg_variance32x64_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance64x32 = vpx_highbd_12_sub_pixel_avg_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance64x32 = vpx_highbd_12_sub_pixel_avg_variance64x32_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance64x64 = vpx_highbd_12_sub_pixel_avg_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance64x64 = vpx_highbd_12_sub_pixel_avg_variance64x64_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance8x16 = vpx_highbd_12_sub_pixel_avg_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance8x16 = vpx_highbd_12_sub_pixel_avg_variance8x16_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance8x4 = vpx_highbd_12_sub_pixel_avg_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance8x4 = vpx_highbd_12_sub_pixel_avg_variance8x4_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance8x8 = vpx_highbd_12_sub_pixel_avg_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance8x8 = vpx_highbd_12_sub_pixel_avg_variance8x8_sse2;
-    vpx_highbd_12_sub_pixel_variance16x16 = vpx_highbd_12_sub_pixel_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance16x16 = vpx_highbd_12_sub_pixel_variance16x16_sse2;
-    vpx_highbd_12_sub_pixel_variance16x32 = vpx_highbd_12_sub_pixel_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance16x32 = vpx_highbd_12_sub_pixel_variance16x32_sse2;
-    vpx_highbd_12_sub_pixel_variance16x8 = vpx_highbd_12_sub_pixel_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance16x8 = vpx_highbd_12_sub_pixel_variance16x8_sse2;
-    vpx_highbd_12_sub_pixel_variance32x16 = vpx_highbd_12_sub_pixel_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance32x16 = vpx_highbd_12_sub_pixel_variance32x16_sse2;
-    vpx_highbd_12_sub_pixel_variance32x32 = vpx_highbd_12_sub_pixel_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance32x32 = vpx_highbd_12_sub_pixel_variance32x32_sse2;
-    vpx_highbd_12_sub_pixel_variance32x64 = vpx_highbd_12_sub_pixel_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance32x64 = vpx_highbd_12_sub_pixel_variance32x64_sse2;
-    vpx_highbd_12_sub_pixel_variance64x32 = vpx_highbd_12_sub_pixel_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance64x32 = vpx_highbd_12_sub_pixel_variance64x32_sse2;
-    vpx_highbd_12_sub_pixel_variance64x64 = vpx_highbd_12_sub_pixel_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance64x64 = vpx_highbd_12_sub_pixel_variance64x64_sse2;
-    vpx_highbd_12_sub_pixel_variance8x16 = vpx_highbd_12_sub_pixel_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance8x16 = vpx_highbd_12_sub_pixel_variance8x16_sse2;
-    vpx_highbd_12_sub_pixel_variance8x4 = vpx_highbd_12_sub_pixel_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance8x4 = vpx_highbd_12_sub_pixel_variance8x4_sse2;
-    vpx_highbd_12_sub_pixel_variance8x8 = vpx_highbd_12_sub_pixel_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance8x8 = vpx_highbd_12_sub_pixel_variance8x8_sse2;
-    vpx_highbd_12_variance16x16 = vpx_highbd_12_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance16x16 = vpx_highbd_12_variance16x16_sse2;
-    vpx_highbd_12_variance16x32 = vpx_highbd_12_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance16x32 = vpx_highbd_12_variance16x32_sse2;
-    vpx_highbd_12_variance16x8 = vpx_highbd_12_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance16x8 = vpx_highbd_12_variance16x8_sse2;
-    vpx_highbd_12_variance32x16 = vpx_highbd_12_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance32x16 = vpx_highbd_12_variance32x16_sse2;
-    vpx_highbd_12_variance32x32 = vpx_highbd_12_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance32x32 = vpx_highbd_12_variance32x32_sse2;
-    vpx_highbd_12_variance32x64 = vpx_highbd_12_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance32x64 = vpx_highbd_12_variance32x64_sse2;
-    vpx_highbd_12_variance64x32 = vpx_highbd_12_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance64x32 = vpx_highbd_12_variance64x32_sse2;
-    vpx_highbd_12_variance64x64 = vpx_highbd_12_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance64x64 = vpx_highbd_12_variance64x64_sse2;
-    vpx_highbd_12_variance8x16 = vpx_highbd_12_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance8x16 = vpx_highbd_12_variance8x16_sse2;
-    vpx_highbd_12_variance8x8 = vpx_highbd_12_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance8x8 = vpx_highbd_12_variance8x8_sse2;
-    vpx_highbd_8_mse16x16 = vpx_highbd_8_mse16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_mse16x16 = vpx_highbd_8_mse16x16_sse2;
-    vpx_highbd_8_mse8x8 = vpx_highbd_8_mse8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_mse8x8 = vpx_highbd_8_mse8x8_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance16x16 = vpx_highbd_8_sub_pixel_avg_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance16x16 = vpx_highbd_8_sub_pixel_avg_variance16x16_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance16x32 = vpx_highbd_8_sub_pixel_avg_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance16x32 = vpx_highbd_8_sub_pixel_avg_variance16x32_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance16x8 = vpx_highbd_8_sub_pixel_avg_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance16x8 = vpx_highbd_8_sub_pixel_avg_variance16x8_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance32x16 = vpx_highbd_8_sub_pixel_avg_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance32x16 = vpx_highbd_8_sub_pixel_avg_variance32x16_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance32x32 = vpx_highbd_8_sub_pixel_avg_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance32x32 = vpx_highbd_8_sub_pixel_avg_variance32x32_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance32x64 = vpx_highbd_8_sub_pixel_avg_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance32x64 = vpx_highbd_8_sub_pixel_avg_variance32x64_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance64x32 = vpx_highbd_8_sub_pixel_avg_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance64x32 = vpx_highbd_8_sub_pixel_avg_variance64x32_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance64x64 = vpx_highbd_8_sub_pixel_avg_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance64x64 = vpx_highbd_8_sub_pixel_avg_variance64x64_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance8x16 = vpx_highbd_8_sub_pixel_avg_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance8x16 = vpx_highbd_8_sub_pixel_avg_variance8x16_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance8x4 = vpx_highbd_8_sub_pixel_avg_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance8x4 = vpx_highbd_8_sub_pixel_avg_variance8x4_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance8x8 = vpx_highbd_8_sub_pixel_avg_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance8x8 = vpx_highbd_8_sub_pixel_avg_variance8x8_sse2;
-    vpx_highbd_8_sub_pixel_variance16x16 = vpx_highbd_8_sub_pixel_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance16x16 = vpx_highbd_8_sub_pixel_variance16x16_sse2;
-    vpx_highbd_8_sub_pixel_variance16x32 = vpx_highbd_8_sub_pixel_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance16x32 = vpx_highbd_8_sub_pixel_variance16x32_sse2;
-    vpx_highbd_8_sub_pixel_variance16x8 = vpx_highbd_8_sub_pixel_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance16x8 = vpx_highbd_8_sub_pixel_variance16x8_sse2;
-    vpx_highbd_8_sub_pixel_variance32x16 = vpx_highbd_8_sub_pixel_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance32x16 = vpx_highbd_8_sub_pixel_variance32x16_sse2;
-    vpx_highbd_8_sub_pixel_variance32x32 = vpx_highbd_8_sub_pixel_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance32x32 = vpx_highbd_8_sub_pixel_variance32x32_sse2;
-    vpx_highbd_8_sub_pixel_variance32x64 = vpx_highbd_8_sub_pixel_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance32x64 = vpx_highbd_8_sub_pixel_variance32x64_sse2;
-    vpx_highbd_8_sub_pixel_variance64x32 = vpx_highbd_8_sub_pixel_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance64x32 = vpx_highbd_8_sub_pixel_variance64x32_sse2;
-    vpx_highbd_8_sub_pixel_variance64x64 = vpx_highbd_8_sub_pixel_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance64x64 = vpx_highbd_8_sub_pixel_variance64x64_sse2;
-    vpx_highbd_8_sub_pixel_variance8x16 = vpx_highbd_8_sub_pixel_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance8x16 = vpx_highbd_8_sub_pixel_variance8x16_sse2;
-    vpx_highbd_8_sub_pixel_variance8x4 = vpx_highbd_8_sub_pixel_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance8x4 = vpx_highbd_8_sub_pixel_variance8x4_sse2;
-    vpx_highbd_8_sub_pixel_variance8x8 = vpx_highbd_8_sub_pixel_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance8x8 = vpx_highbd_8_sub_pixel_variance8x8_sse2;
-    vpx_highbd_8_variance16x16 = vpx_highbd_8_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance16x16 = vpx_highbd_8_variance16x16_sse2;
-    vpx_highbd_8_variance16x32 = vpx_highbd_8_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance16x32 = vpx_highbd_8_variance16x32_sse2;
-    vpx_highbd_8_variance16x8 = vpx_highbd_8_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance16x8 = vpx_highbd_8_variance16x8_sse2;
-    vpx_highbd_8_variance32x16 = vpx_highbd_8_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance32x16 = vpx_highbd_8_variance32x16_sse2;
-    vpx_highbd_8_variance32x32 = vpx_highbd_8_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance32x32 = vpx_highbd_8_variance32x32_sse2;
-    vpx_highbd_8_variance32x64 = vpx_highbd_8_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance32x64 = vpx_highbd_8_variance32x64_sse2;
-    vpx_highbd_8_variance64x32 = vpx_highbd_8_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance64x32 = vpx_highbd_8_variance64x32_sse2;
-    vpx_highbd_8_variance64x64 = vpx_highbd_8_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance64x64 = vpx_highbd_8_variance64x64_sse2;
-    vpx_highbd_8_variance8x16 = vpx_highbd_8_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance8x16 = vpx_highbd_8_variance8x16_sse2;
-    vpx_highbd_8_variance8x8 = vpx_highbd_8_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance8x8 = vpx_highbd_8_variance8x8_sse2;
-    vpx_highbd_convolve8 = vpx_highbd_convolve8_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8 = vpx_highbd_convolve8_avx2;
-    vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_avx2;
-    vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_avx2;
-    vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_avx2;
-    vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_avx2;
-    vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_avx2;
-    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_avx2;
-    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_c;
-    if (flags & HAS_SSE2) vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_avx2;
-    vpx_highbd_dc_predictor_16x16 = vpx_highbd_dc_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_dc_predictor_16x16 = vpx_highbd_dc_predictor_16x16_sse2;
-    vpx_highbd_dc_predictor_32x32 = vpx_highbd_dc_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_dc_predictor_32x32 = vpx_highbd_dc_predictor_32x32_sse2;
-    vpx_highbd_dc_predictor_4x4 = vpx_highbd_dc_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_dc_predictor_4x4 = vpx_highbd_dc_predictor_4x4_sse2;
-    vpx_highbd_dc_predictor_8x8 = vpx_highbd_dc_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_dc_predictor_8x8 = vpx_highbd_dc_predictor_8x8_sse2;
-    vpx_highbd_fdct16x16 = vpx_highbd_fdct16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct16x16 = vpx_highbd_fdct16x16_sse2;
-    vpx_highbd_fdct32x32 = vpx_highbd_fdct32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct32x32 = vpx_highbd_fdct32x32_sse2;
-    vpx_highbd_fdct32x32_rd = vpx_highbd_fdct32x32_rd_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct32x32_rd = vpx_highbd_fdct32x32_rd_sse2;
-    vpx_highbd_fdct4x4 = vpx_highbd_fdct4x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct4x4 = vpx_highbd_fdct4x4_sse2;
-    vpx_highbd_fdct8x8 = vpx_highbd_fdct8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct8x8 = vpx_highbd_fdct8x8_sse2;
-    vpx_highbd_idct16x16_10_add = vpx_highbd_idct16x16_10_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct16x16_10_add = vpx_highbd_idct16x16_10_add_sse2;
-    vpx_highbd_idct16x16_1_add = vpx_highbd_idct16x16_1_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct16x16_1_add = vpx_highbd_idct16x16_1_add_sse2;
-    vpx_highbd_idct16x16_256_add = vpx_highbd_idct16x16_256_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct16x16_256_add = vpx_highbd_idct16x16_256_add_sse2;
-    vpx_highbd_idct16x16_38_add = vpx_highbd_idct16x16_38_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct16x16_38_add = vpx_highbd_idct16x16_256_add_sse2;
-    vpx_highbd_idct32x32_1_add = vpx_highbd_idct32x32_1_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct32x32_1_add = vpx_highbd_idct32x32_1_add_sse2;
-    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse4_1;
-    vpx_highbd_idct4x4_1_add = vpx_highbd_idct4x4_1_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct4x4_1_add = vpx_highbd_idct4x4_1_add_sse2;
-    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse4_1;
-    vpx_highbd_idct8x8_1_add = vpx_highbd_idct8x8_1_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct8x8_1_add = vpx_highbd_idct8x8_1_add_sse2;
-    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse4_1;
-    vpx_highbd_lpf_horizontal_16 = vpx_highbd_lpf_horizontal_16_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_16 = vpx_highbd_lpf_horizontal_16_sse2;
-    vpx_highbd_lpf_horizontal_16_dual = vpx_highbd_lpf_horizontal_16_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_16_dual = vpx_highbd_lpf_horizontal_16_dual_sse2;
-    vpx_highbd_lpf_horizontal_4 = vpx_highbd_lpf_horizontal_4_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_4 = vpx_highbd_lpf_horizontal_4_sse2;
-    vpx_highbd_lpf_horizontal_4_dual = vpx_highbd_lpf_horizontal_4_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_4_dual = vpx_highbd_lpf_horizontal_4_dual_sse2;
-    vpx_highbd_lpf_horizontal_8 = vpx_highbd_lpf_horizontal_8_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_8 = vpx_highbd_lpf_horizontal_8_sse2;
-    vpx_highbd_lpf_horizontal_8_dual = vpx_highbd_lpf_horizontal_8_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_8_dual = vpx_highbd_lpf_horizontal_8_dual_sse2;
-    vpx_highbd_lpf_vertical_16 = vpx_highbd_lpf_vertical_16_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_16 = vpx_highbd_lpf_vertical_16_sse2;
-    vpx_highbd_lpf_vertical_16_dual = vpx_highbd_lpf_vertical_16_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_16_dual = vpx_highbd_lpf_vertical_16_dual_sse2;
-    vpx_highbd_lpf_vertical_4 = vpx_highbd_lpf_vertical_4_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_4 = vpx_highbd_lpf_vertical_4_sse2;
-    vpx_highbd_lpf_vertical_4_dual = vpx_highbd_lpf_vertical_4_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_4_dual = vpx_highbd_lpf_vertical_4_dual_sse2;
-    vpx_highbd_lpf_vertical_8 = vpx_highbd_lpf_vertical_8_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_8 = vpx_highbd_lpf_vertical_8_sse2;
-    vpx_highbd_lpf_vertical_8_dual = vpx_highbd_lpf_vertical_8_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_8_dual = vpx_highbd_lpf_vertical_8_dual_sse2;
-    vpx_highbd_quantize_b = vpx_highbd_quantize_b_c;
-    if (flags & HAS_SSE2) vpx_highbd_quantize_b = vpx_highbd_quantize_b_sse2;
-    vpx_highbd_quantize_b_32x32 = vpx_highbd_quantize_b_32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_quantize_b_32x32 = vpx_highbd_quantize_b_32x32_sse2;
-    vpx_highbd_sad16x16 = vpx_highbd_sad16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x16 = vpx_highbd_sad16x16_sse2;
-    vpx_highbd_sad16x16_avg = vpx_highbd_sad16x16_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x16_avg = vpx_highbd_sad16x16_avg_sse2;
-    vpx_highbd_sad16x16x4d = vpx_highbd_sad16x16x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x16x4d = vpx_highbd_sad16x16x4d_sse2;
-    vpx_highbd_sad16x32 = vpx_highbd_sad16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x32 = vpx_highbd_sad16x32_sse2;
-    vpx_highbd_sad16x32_avg = vpx_highbd_sad16x32_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x32_avg = vpx_highbd_sad16x32_avg_sse2;
-    vpx_highbd_sad16x32x4d = vpx_highbd_sad16x32x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x32x4d = vpx_highbd_sad16x32x4d_sse2;
-    vpx_highbd_sad16x8 = vpx_highbd_sad16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x8 = vpx_highbd_sad16x8_sse2;
-    vpx_highbd_sad16x8_avg = vpx_highbd_sad16x8_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x8_avg = vpx_highbd_sad16x8_avg_sse2;
-    vpx_highbd_sad16x8x4d = vpx_highbd_sad16x8x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x8x4d = vpx_highbd_sad16x8x4d_sse2;
-    vpx_highbd_sad32x16 = vpx_highbd_sad32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x16 = vpx_highbd_sad32x16_sse2;
-    vpx_highbd_sad32x16_avg = vpx_highbd_sad32x16_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x16_avg = vpx_highbd_sad32x16_avg_sse2;
-    vpx_highbd_sad32x16x4d = vpx_highbd_sad32x16x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x16x4d = vpx_highbd_sad32x16x4d_sse2;
-    vpx_highbd_sad32x32 = vpx_highbd_sad32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x32 = vpx_highbd_sad32x32_sse2;
-    vpx_highbd_sad32x32_avg = vpx_highbd_sad32x32_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x32_avg = vpx_highbd_sad32x32_avg_sse2;
-    vpx_highbd_sad32x32x4d = vpx_highbd_sad32x32x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x32x4d = vpx_highbd_sad32x32x4d_sse2;
-    vpx_highbd_sad32x64 = vpx_highbd_sad32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x64 = vpx_highbd_sad32x64_sse2;
-    vpx_highbd_sad32x64_avg = vpx_highbd_sad32x64_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x64_avg = vpx_highbd_sad32x64_avg_sse2;
-    vpx_highbd_sad32x64x4d = vpx_highbd_sad32x64x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x64x4d = vpx_highbd_sad32x64x4d_sse2;
-    vpx_highbd_sad4x4x4d = vpx_highbd_sad4x4x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad4x4x4d = vpx_highbd_sad4x4x4d_sse2;
-    vpx_highbd_sad4x8x4d = vpx_highbd_sad4x8x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad4x8x4d = vpx_highbd_sad4x8x4d_sse2;
-    vpx_highbd_sad64x32 = vpx_highbd_sad64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x32 = vpx_highbd_sad64x32_sse2;
-    vpx_highbd_sad64x32_avg = vpx_highbd_sad64x32_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x32_avg = vpx_highbd_sad64x32_avg_sse2;
-    vpx_highbd_sad64x32x4d = vpx_highbd_sad64x32x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x32x4d = vpx_highbd_sad64x32x4d_sse2;
-    vpx_highbd_sad64x64 = vpx_highbd_sad64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x64 = vpx_highbd_sad64x64_sse2;
-    vpx_highbd_sad64x64_avg = vpx_highbd_sad64x64_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x64_avg = vpx_highbd_sad64x64_avg_sse2;
-    vpx_highbd_sad64x64x4d = vpx_highbd_sad64x64x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x64x4d = vpx_highbd_sad64x64x4d_sse2;
-    vpx_highbd_sad8x16 = vpx_highbd_sad8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x16 = vpx_highbd_sad8x16_sse2;
-    vpx_highbd_sad8x16_avg = vpx_highbd_sad8x16_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x16_avg = vpx_highbd_sad8x16_avg_sse2;
-    vpx_highbd_sad8x16x4d = vpx_highbd_sad8x16x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x16x4d = vpx_highbd_sad8x16x4d_sse2;
-    vpx_highbd_sad8x4 = vpx_highbd_sad8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x4 = vpx_highbd_sad8x4_sse2;
-    vpx_highbd_sad8x4_avg = vpx_highbd_sad8x4_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x4_avg = vpx_highbd_sad8x4_avg_sse2;
-    vpx_highbd_sad8x4x4d = vpx_highbd_sad8x4x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x4x4d = vpx_highbd_sad8x4x4d_sse2;
-    vpx_highbd_sad8x8 = vpx_highbd_sad8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x8 = vpx_highbd_sad8x8_sse2;
-    vpx_highbd_sad8x8_avg = vpx_highbd_sad8x8_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x8_avg = vpx_highbd_sad8x8_avg_sse2;
-    vpx_highbd_sad8x8x4d = vpx_highbd_sad8x8x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x8x4d = vpx_highbd_sad8x8x4d_sse2;
-    vpx_highbd_tm_predictor_16x16 = vpx_highbd_tm_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_tm_predictor_16x16 = vpx_highbd_tm_predictor_16x16_sse2;
-    vpx_highbd_tm_predictor_32x32 = vpx_highbd_tm_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_tm_predictor_32x32 = vpx_highbd_tm_predictor_32x32_sse2;
-    vpx_highbd_tm_predictor_4x4 = vpx_highbd_tm_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_tm_predictor_4x4 = vpx_highbd_tm_predictor_4x4_sse2;
-    vpx_highbd_tm_predictor_8x8 = vpx_highbd_tm_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_tm_predictor_8x8 = vpx_highbd_tm_predictor_8x8_sse2;
-    vpx_highbd_v_predictor_16x16 = vpx_highbd_v_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_v_predictor_16x16 = vpx_highbd_v_predictor_16x16_sse2;
-    vpx_highbd_v_predictor_32x32 = vpx_highbd_v_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_v_predictor_32x32 = vpx_highbd_v_predictor_32x32_sse2;
-    vpx_highbd_v_predictor_4x4 = vpx_highbd_v_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_v_predictor_4x4 = vpx_highbd_v_predictor_4x4_sse2;
-    vpx_highbd_v_predictor_8x8 = vpx_highbd_v_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_v_predictor_8x8 = vpx_highbd_v_predictor_8x8_sse2;
-    vpx_idct16x16_10_add = vpx_idct16x16_10_add_c;
-    if (flags & HAS_SSE2) vpx_idct16x16_10_add = vpx_idct16x16_10_add_sse2;
-    vpx_idct16x16_1_add = vpx_idct16x16_1_add_c;
-    if (flags & HAS_SSE2) vpx_idct16x16_1_add = vpx_idct16x16_1_add_sse2;
-    vpx_idct16x16_256_add = vpx_idct16x16_256_add_c;
-    if (flags & HAS_SSE2) vpx_idct16x16_256_add = vpx_idct16x16_256_add_sse2;
-    vpx_idct16x16_38_add = vpx_idct16x16_38_add_c;
-    if (flags & HAS_SSE2) vpx_idct16x16_38_add = vpx_idct16x16_38_add_sse2;
-    vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_c;
-    if (flags & HAS_SSE2) vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_sse2;
-    vpx_idct32x32_135_add = vpx_idct32x32_135_add_c;
-    if (flags & HAS_SSE2) vpx_idct32x32_135_add = vpx_idct32x32_1024_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct32x32_135_add = vpx_idct32x32_135_add_ssse3;
-    vpx_idct32x32_1_add = vpx_idct32x32_1_add_c;
-    if (flags & HAS_SSE2) vpx_idct32x32_1_add = vpx_idct32x32_1_add_sse2;
-    vpx_idct32x32_34_add = vpx_idct32x32_34_add_c;
-    if (flags & HAS_SSE2) vpx_idct32x32_34_add = vpx_idct32x32_34_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct32x32_34_add = vpx_idct32x32_34_add_ssse3;
-    vpx_idct4x4_16_add = vpx_idct4x4_16_add_c;
-    if (flags & HAS_SSE2) vpx_idct4x4_16_add = vpx_idct4x4_16_add_sse2;
-    vpx_idct4x4_1_add = vpx_idct4x4_1_add_c;
-    if (flags & HAS_SSE2) vpx_idct4x4_1_add = vpx_idct4x4_1_add_sse2;
-    vpx_idct8x8_12_add = vpx_idct8x8_12_add_c;
-    if (flags & HAS_SSE2) vpx_idct8x8_12_add = vpx_idct8x8_12_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct8x8_12_add = vpx_idct8x8_12_add_ssse3;
-    vpx_idct8x8_1_add = vpx_idct8x8_1_add_c;
-    if (flags & HAS_SSE2) vpx_idct8x8_1_add = vpx_idct8x8_1_add_sse2;
-    vpx_idct8x8_64_add = vpx_idct8x8_64_add_c;
-    if (flags & HAS_SSE2) vpx_idct8x8_64_add = vpx_idct8x8_64_add_sse2;
-    vpx_int_pro_col = vpx_int_pro_col_c;
-    if (flags & HAS_SSE2) vpx_int_pro_col = vpx_int_pro_col_sse2;
-    vpx_int_pro_row = vpx_int_pro_row_c;
-    if (flags & HAS_SSE2) vpx_int_pro_row = vpx_int_pro_row_sse2;
-    vpx_iwht4x4_16_add = vpx_iwht4x4_16_add_c;
-    if (flags & HAS_SSE2) vpx_iwht4x4_16_add = vpx_iwht4x4_16_add_sse2;
-    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_sse2;
-    if (flags & HAS_AVX2) vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_avx2;
-    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_sse2;
-    if (flags & HAS_AVX2) vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_avx2;
-    vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_sse2;
-    vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_sse2;
-    vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_sse2;
-    vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_sse2;
-    vpx_lpf_vertical_16 = vpx_lpf_vertical_16_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_16 = vpx_lpf_vertical_16_sse2;
-    vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_sse2;
-    vpx_lpf_vertical_4 = vpx_lpf_vertical_4_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_4 = vpx_lpf_vertical_4_sse2;
-    vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_sse2;
-    vpx_lpf_vertical_8 = vpx_lpf_vertical_8_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_8 = vpx_lpf_vertical_8_sse2;
-    vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_sse2;
-    vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_c;
-    if (flags & HAS_SSE2) vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_sse2;
-    vpx_mbpost_proc_down = vpx_mbpost_proc_down_c;
-    if (flags & HAS_SSE2) vpx_mbpost_proc_down = vpx_mbpost_proc_down_sse2;
-    vpx_minmax_8x8 = vpx_minmax_8x8_c;
-    if (flags & HAS_SSE2) vpx_minmax_8x8 = vpx_minmax_8x8_sse2;
-    vpx_mse16x16 = vpx_mse16x16_c;
-    if (flags & HAS_SSE2) vpx_mse16x16 = vpx_mse16x16_sse2;
-    if (flags & HAS_AVX2) vpx_mse16x16 = vpx_mse16x16_avx2;
-    vpx_mse16x8 = vpx_mse16x8_c;
-    if (flags & HAS_SSE2) vpx_mse16x8 = vpx_mse16x8_sse2;
-    vpx_mse8x16 = vpx_mse8x16_c;
-    if (flags & HAS_SSE2) vpx_mse8x16 = vpx_mse8x16_sse2;
-    vpx_mse8x8 = vpx_mse8x8_c;
-    if (flags & HAS_SSE2) vpx_mse8x8 = vpx_mse8x8_sse2;
-    vpx_plane_add_noise = vpx_plane_add_noise_c;
-    if (flags & HAS_SSE2) vpx_plane_add_noise = vpx_plane_add_noise_sse2;
-    vpx_post_proc_down_and_across_mb_row = vpx_post_proc_down_and_across_mb_row_c;
-    if (flags & HAS_SSE2) vpx_post_proc_down_and_across_mb_row = vpx_post_proc_down_and_across_mb_row_sse2;
-    vpx_quantize_b = vpx_quantize_b_c;
-    if (flags & HAS_SSE2) vpx_quantize_b = vpx_quantize_b_sse2;
-    vpx_sad16x16 = vpx_sad16x16_c;
-    if (flags & HAS_SSE2) vpx_sad16x16 = vpx_sad16x16_sse2;
-    vpx_sad16x16_avg = vpx_sad16x16_avg_c;
-    if (flags & HAS_SSE2) vpx_sad16x16_avg = vpx_sad16x16_avg_sse2;
-    vpx_sad16x16x3 = vpx_sad16x16x3_c;
-    if (flags & HAS_SSE3) vpx_sad16x16x3 = vpx_sad16x16x3_sse3;
-    if (flags & HAS_SSSE3) vpx_sad16x16x3 = vpx_sad16x16x3_ssse3;
-    vpx_sad16x16x4d = vpx_sad16x16x4d_c;
-    if (flags & HAS_SSE2) vpx_sad16x16x4d = vpx_sad16x16x4d_sse2;
-    vpx_sad16x16x8 = vpx_sad16x16x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad16x16x8 = vpx_sad16x16x8_sse4_1;
-    vpx_sad16x32 = vpx_sad16x32_c;
-    if (flags & HAS_SSE2) vpx_sad16x32 = vpx_sad16x32_sse2;
-    vpx_sad16x32_avg = vpx_sad16x32_avg_c;
-    if (flags & HAS_SSE2) vpx_sad16x32_avg = vpx_sad16x32_avg_sse2;
-    vpx_sad16x32x4d = vpx_sad16x32x4d_c;
-    if (flags & HAS_SSE2) vpx_sad16x32x4d = vpx_sad16x32x4d_sse2;
-    vpx_sad16x8 = vpx_sad16x8_c;
-    if (flags & HAS_SSE2) vpx_sad16x8 = vpx_sad16x8_sse2;
-    vpx_sad16x8_avg = vpx_sad16x8_avg_c;
-    if (flags & HAS_SSE2) vpx_sad16x8_avg = vpx_sad16x8_avg_sse2;
-    vpx_sad16x8x3 = vpx_sad16x8x3_c;
-    if (flags & HAS_SSE3) vpx_sad16x8x3 = vpx_sad16x8x3_sse3;
-    if (flags & HAS_SSSE3) vpx_sad16x8x3 = vpx_sad16x8x3_ssse3;
-    vpx_sad16x8x4d = vpx_sad16x8x4d_c;
-    if (flags & HAS_SSE2) vpx_sad16x8x4d = vpx_sad16x8x4d_sse2;
-    vpx_sad16x8x8 = vpx_sad16x8x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad16x8x8 = vpx_sad16x8x8_sse4_1;
-    vpx_sad32x16 = vpx_sad32x16_c;
-    if (flags & HAS_SSE2) vpx_sad32x16 = vpx_sad32x16_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x16 = vpx_sad32x16_avx2;
-    vpx_sad32x16_avg = vpx_sad32x16_avg_c;
-    if (flags & HAS_SSE2) vpx_sad32x16_avg = vpx_sad32x16_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x16_avg = vpx_sad32x16_avg_avx2;
-    vpx_sad32x16x4d = vpx_sad32x16x4d_c;
-    if (flags & HAS_SSE2) vpx_sad32x16x4d = vpx_sad32x16x4d_sse2;
-    vpx_sad32x32 = vpx_sad32x32_c;
-    if (flags & HAS_SSE2) vpx_sad32x32 = vpx_sad32x32_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32 = vpx_sad32x32_avx2;
-    vpx_sad32x32_avg = vpx_sad32x32_avg_c;
-    if (flags & HAS_SSE2) vpx_sad32x32_avg = vpx_sad32x32_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32_avg = vpx_sad32x32_avg_avx2;
-    vpx_sad32x32x4d = vpx_sad32x32x4d_c;
-    if (flags & HAS_SSE2) vpx_sad32x32x4d = vpx_sad32x32x4d_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32x4d = vpx_sad32x32x4d_avx2;
-    vpx_sad32x64 = vpx_sad32x64_c;
-    if (flags & HAS_SSE2) vpx_sad32x64 = vpx_sad32x64_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x64 = vpx_sad32x64_avx2;
-    vpx_sad32x64_avg = vpx_sad32x64_avg_c;
-    if (flags & HAS_SSE2) vpx_sad32x64_avg = vpx_sad32x64_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x64_avg = vpx_sad32x64_avg_avx2;
-    vpx_sad32x64x4d = vpx_sad32x64x4d_c;
-    if (flags & HAS_SSE2) vpx_sad32x64x4d = vpx_sad32x64x4d_sse2;
-    vpx_sad4x4 = vpx_sad4x4_c;
-    if (flags & HAS_SSE2) vpx_sad4x4 = vpx_sad4x4_sse2;
-    vpx_sad4x4_avg = vpx_sad4x4_avg_c;
-    if (flags & HAS_SSE2) vpx_sad4x4_avg = vpx_sad4x4_avg_sse2;
-    vpx_sad4x4x3 = vpx_sad4x4x3_c;
-    if (flags & HAS_SSE3) vpx_sad4x4x3 = vpx_sad4x4x3_sse3;
-    vpx_sad4x4x4d = vpx_sad4x4x4d_c;
-    if (flags & HAS_SSE2) vpx_sad4x4x4d = vpx_sad4x4x4d_sse2;
-    vpx_sad4x4x8 = vpx_sad4x4x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad4x4x8 = vpx_sad4x4x8_sse4_1;
-    vpx_sad4x8 = vpx_sad4x8_c;
-    if (flags & HAS_SSE2) vpx_sad4x8 = vpx_sad4x8_sse2;
-    vpx_sad4x8_avg = vpx_sad4x8_avg_c;
-    if (flags & HAS_SSE2) vpx_sad4x8_avg = vpx_sad4x8_avg_sse2;
-    vpx_sad4x8x4d = vpx_sad4x8x4d_c;
-    if (flags & HAS_SSE2) vpx_sad4x8x4d = vpx_sad4x8x4d_sse2;
-    vpx_sad64x32 = vpx_sad64x32_c;
-    if (flags & HAS_SSE2) vpx_sad64x32 = vpx_sad64x32_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x32 = vpx_sad64x32_avx2;
-    vpx_sad64x32_avg = vpx_sad64x32_avg_c;
-    if (flags & HAS_SSE2) vpx_sad64x32_avg = vpx_sad64x32_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x32_avg = vpx_sad64x32_avg_avx2;
-    vpx_sad64x32x4d = vpx_sad64x32x4d_c;
-    if (flags & HAS_SSE2) vpx_sad64x32x4d = vpx_sad64x32x4d_sse2;
-    vpx_sad64x64 = vpx_sad64x64_c;
-    if (flags & HAS_SSE2) vpx_sad64x64 = vpx_sad64x64_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64 = vpx_sad64x64_avx2;
-    vpx_sad64x64_avg = vpx_sad64x64_avg_c;
-    if (flags & HAS_SSE2) vpx_sad64x64_avg = vpx_sad64x64_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64_avg = vpx_sad64x64_avg_avx2;
-    vpx_sad64x64x4d = vpx_sad64x64x4d_c;
-    if (flags & HAS_SSE2) vpx_sad64x64x4d = vpx_sad64x64x4d_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64x4d = vpx_sad64x64x4d_avx2;
-    vpx_sad8x16 = vpx_sad8x16_c;
-    if (flags & HAS_SSE2) vpx_sad8x16 = vpx_sad8x16_sse2;
-    vpx_sad8x16_avg = vpx_sad8x16_avg_c;
-    if (flags & HAS_SSE2) vpx_sad8x16_avg = vpx_sad8x16_avg_sse2;
-    vpx_sad8x16x3 = vpx_sad8x16x3_c;
-    if (flags & HAS_SSE3) vpx_sad8x16x3 = vpx_sad8x16x3_sse3;
-    vpx_sad8x16x4d = vpx_sad8x16x4d_c;
-    if (flags & HAS_SSE2) vpx_sad8x16x4d = vpx_sad8x16x4d_sse2;
-    vpx_sad8x16x8 = vpx_sad8x16x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad8x16x8 = vpx_sad8x16x8_sse4_1;
-    vpx_sad8x4 = vpx_sad8x4_c;
-    if (flags & HAS_SSE2) vpx_sad8x4 = vpx_sad8x4_sse2;
-    vpx_sad8x4_avg = vpx_sad8x4_avg_c;
-    if (flags & HAS_SSE2) vpx_sad8x4_avg = vpx_sad8x4_avg_sse2;
-    vpx_sad8x4x4d = vpx_sad8x4x4d_c;
-    if (flags & HAS_SSE2) vpx_sad8x4x4d = vpx_sad8x4x4d_sse2;
-    vpx_sad8x8 = vpx_sad8x8_c;
-    if (flags & HAS_SSE2) vpx_sad8x8 = vpx_sad8x8_sse2;
-    vpx_sad8x8_avg = vpx_sad8x8_avg_c;
-    if (flags & HAS_SSE2) vpx_sad8x8_avg = vpx_sad8x8_avg_sse2;
-    vpx_sad8x8x3 = vpx_sad8x8x3_c;
-    if (flags & HAS_SSE3) vpx_sad8x8x3 = vpx_sad8x8x3_sse3;
-    vpx_sad8x8x4d = vpx_sad8x8x4d_c;
-    if (flags & HAS_SSE2) vpx_sad8x8x4d = vpx_sad8x8x4d_sse2;
-    vpx_sad8x8x8 = vpx_sad8x8x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad8x8x8 = vpx_sad8x8x8_sse4_1;
-    vpx_satd = vpx_satd_c;
-    if (flags & HAS_SSE2) vpx_satd = vpx_satd_sse2;
-    vpx_scaled_2d = vpx_scaled_2d_c;
-    if (flags & HAS_SSSE3) vpx_scaled_2d = vpx_scaled_2d_ssse3;
-    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_ssse3;
-    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_ssse3;
-    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_ssse3;
-    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_ssse3;
-    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_avx2;
-    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_ssse3;
-    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_ssse3;
-    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_ssse3;
-    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_ssse3;
-    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_avx2;
-    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_ssse3;
-    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_ssse3;
-    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_ssse3;
-    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_ssse3;
-    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_ssse3;
-    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_ssse3;
-    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_ssse3;
-    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_avx2;
-    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_ssse3;
-    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_ssse3;
-    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_ssse3;
-    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_ssse3;
-    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_avx2;
-    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_ssse3;
-    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_ssse3;
-    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_ssse3;
-    vpx_subtract_block = vpx_subtract_block_c;
-    if (flags & HAS_SSE2) vpx_subtract_block = vpx_subtract_block_sse2;
-    vpx_sum_squares_2d_i16 = vpx_sum_squares_2d_i16_c;
-    if (flags & HAS_SSE2) vpx_sum_squares_2d_i16 = vpx_sum_squares_2d_i16_sse2;
-    vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_sse2;
-    vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_sse2;
-    vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_sse2;
-    vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_sse2;
-    vpx_v_predictor_16x16 = vpx_v_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_v_predictor_16x16 = vpx_v_predictor_16x16_sse2;
-    vpx_v_predictor_32x32 = vpx_v_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_v_predictor_32x32 = vpx_v_predictor_32x32_sse2;
-    vpx_v_predictor_4x4 = vpx_v_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_v_predictor_4x4 = vpx_v_predictor_4x4_sse2;
-    vpx_v_predictor_8x8 = vpx_v_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_v_predictor_8x8 = vpx_v_predictor_8x8_sse2;
-    vpx_variance16x16 = vpx_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_variance16x16 = vpx_variance16x16_sse2;
-    if (flags & HAS_AVX2) vpx_variance16x16 = vpx_variance16x16_avx2;
-    vpx_variance16x32 = vpx_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_variance16x32 = vpx_variance16x32_sse2;
-    vpx_variance16x8 = vpx_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_variance16x8 = vpx_variance16x8_sse2;
-    vpx_variance32x16 = vpx_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_variance32x16 = vpx_variance32x16_sse2;
-    if (flags & HAS_AVX2) vpx_variance32x16 = vpx_variance32x16_avx2;
-    vpx_variance32x32 = vpx_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_variance32x32 = vpx_variance32x32_sse2;
-    if (flags & HAS_AVX2) vpx_variance32x32 = vpx_variance32x32_avx2;
-    vpx_variance32x64 = vpx_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_variance32x64 = vpx_variance32x64_sse2;
-    vpx_variance4x4 = vpx_variance4x4_c;
-    if (flags & HAS_SSE2) vpx_variance4x4 = vpx_variance4x4_sse2;
-    vpx_variance4x8 = vpx_variance4x8_c;
-    if (flags & HAS_SSE2) vpx_variance4x8 = vpx_variance4x8_sse2;
-    vpx_variance64x32 = vpx_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_variance64x32 = vpx_variance64x32_sse2;
-    if (flags & HAS_AVX2) vpx_variance64x32 = vpx_variance64x32_avx2;
-    vpx_variance64x64 = vpx_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_variance64x64 = vpx_variance64x64_sse2;
-    if (flags & HAS_AVX2) vpx_variance64x64 = vpx_variance64x64_avx2;
-    vpx_variance8x16 = vpx_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_variance8x16 = vpx_variance8x16_sse2;
-    vpx_variance8x4 = vpx_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_variance8x4 = vpx_variance8x4_sse2;
-    vpx_variance8x8 = vpx_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_variance8x8 = vpx_variance8x8_sse2;
-    vpx_vector_var = vpx_vector_var_c;
-    if (flags & HAS_SSE2) vpx_vector_var = vpx_vector_var_sse2;
+  vpx_avg_4x4 = vpx_avg_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_avg_4x4 = vpx_avg_4x4_sse2;
+  vpx_avg_8x8 = vpx_avg_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_avg_8x8 = vpx_avg_8x8_sse2;
+  vpx_comp_avg_pred = vpx_comp_avg_pred_c;
+  if (flags & HAS_SSE2)
+    vpx_comp_avg_pred = vpx_comp_avg_pred_sse2;
+  vpx_convolve8 = vpx_convolve8_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8 = vpx_convolve8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8 = vpx_convolve8_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8 = vpx_convolve8_avx2;
+  vpx_convolve8_avg = vpx_convolve8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_avg = vpx_convolve8_avg_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg = vpx_convolve8_avg_ssse3;
+  vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_ssse3;
+  vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_ssse3;
+  vpx_convolve8_horiz = vpx_convolve8_horiz_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_avx2;
+  vpx_convolve8_vert = vpx_convolve8_vert_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_vert = vpx_convolve8_vert_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_vert = vpx_convolve8_vert_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8_vert = vpx_convolve8_vert_avx2;
+  vpx_convolve_avg = vpx_convolve_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve_avg = vpx_convolve_avg_sse2;
+  vpx_convolve_copy = vpx_convolve_copy_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve_copy = vpx_convolve_copy_sse2;
+  vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_ssse3;
+  vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_ssse3;
+  vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_ssse3;
+  vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_ssse3;
+  vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_ssse3;
+  vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_ssse3;
+  vpx_d207_predictor_4x4 = vpx_d207_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_d207_predictor_4x4 = vpx_d207_predictor_4x4_sse2;
+  vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_ssse3;
+  vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_ssse3;
+  vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_ssse3;
+  vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_sse2;
+  vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_sse2;
+  vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_ssse3;
+  vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_ssse3;
+  vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_ssse3;
+  vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_ssse3;
+  vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_sse2;
+  vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_sse2;
+  vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_sse2;
+  vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_sse2;
+  vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_sse2;
+  vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_sse2;
+  vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_sse2;
+  vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_sse2;
+  vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_sse2;
+  vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_sse2;
+  vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_sse2;
+  vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_sse2;
+  vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_sse2;
+  vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_sse2;
+  vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_sse2;
+  vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_sse2;
+  vpx_fdct16x16 = vpx_fdct16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct16x16 = vpx_fdct16x16_sse2;
+  vpx_fdct16x16_1 = vpx_fdct16x16_1_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct16x16_1 = vpx_fdct16x16_1_sse2;
+  vpx_fdct32x32 = vpx_fdct32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct32x32 = vpx_fdct32x32_sse2;
+  vpx_fdct32x32_1 = vpx_fdct32x32_1_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct32x32_1 = vpx_fdct32x32_1_sse2;
+  vpx_fdct32x32_rd = vpx_fdct32x32_rd_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct32x32_rd = vpx_fdct32x32_rd_sse2;
+  vpx_fdct4x4 = vpx_fdct4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct4x4 = vpx_fdct4x4_sse2;
+  vpx_fdct4x4_1 = vpx_fdct4x4_1_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct4x4_1 = vpx_fdct4x4_1_sse2;
+  vpx_fdct8x8 = vpx_fdct8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct8x8 = vpx_fdct8x8_sse2;
+  vpx_fdct8x8_1 = vpx_fdct8x8_1_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct8x8_1 = vpx_fdct8x8_1_sse2;
+  vpx_get16x16var = vpx_get16x16var_c;
+  if (flags & HAS_SSE2)
+    vpx_get16x16var = vpx_get16x16var_sse2;
+  if (flags & HAS_AVX2)
+    vpx_get16x16var = vpx_get16x16var_avx2;
+  vpx_get8x8var = vpx_get8x8var_c;
+  if (flags & HAS_SSE2)
+    vpx_get8x8var = vpx_get8x8var_sse2;
+  vpx_get_mb_ss = vpx_get_mb_ss_c;
+  if (flags & HAS_SSE2)
+    vpx_get_mb_ss = vpx_get_mb_ss_sse2;
+  vpx_h_predictor_16x16 = vpx_h_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_h_predictor_16x16 = vpx_h_predictor_16x16_sse2;
+  vpx_h_predictor_32x32 = vpx_h_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_h_predictor_32x32 = vpx_h_predictor_32x32_sse2;
+  vpx_h_predictor_4x4 = vpx_h_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_h_predictor_4x4 = vpx_h_predictor_4x4_sse2;
+  vpx_h_predictor_8x8 = vpx_h_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_h_predictor_8x8 = vpx_h_predictor_8x8_sse2;
+  vpx_hadamard_16x16 = vpx_hadamard_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_hadamard_16x16 = vpx_hadamard_16x16_sse2;
+  vpx_hadamard_8x8 = vpx_hadamard_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_hadamard_8x8 = vpx_hadamard_8x8_sse2;
+  vpx_highbd_10_mse16x16 = vpx_highbd_10_mse16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_mse16x16 = vpx_highbd_10_mse16x16_sse2;
+  vpx_highbd_10_mse8x8 = vpx_highbd_10_mse8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_mse8x8 = vpx_highbd_10_mse8x8_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance16x16 =
+      vpx_highbd_10_sub_pixel_avg_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance16x16 =
+        vpx_highbd_10_sub_pixel_avg_variance16x16_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance16x32 =
+      vpx_highbd_10_sub_pixel_avg_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance16x32 =
+        vpx_highbd_10_sub_pixel_avg_variance16x32_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance16x8 =
+      vpx_highbd_10_sub_pixel_avg_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance16x8 =
+        vpx_highbd_10_sub_pixel_avg_variance16x8_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance32x16 =
+      vpx_highbd_10_sub_pixel_avg_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance32x16 =
+        vpx_highbd_10_sub_pixel_avg_variance32x16_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance32x32 =
+      vpx_highbd_10_sub_pixel_avg_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance32x32 =
+        vpx_highbd_10_sub_pixel_avg_variance32x32_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance32x64 =
+      vpx_highbd_10_sub_pixel_avg_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance32x64 =
+        vpx_highbd_10_sub_pixel_avg_variance32x64_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance64x32 =
+      vpx_highbd_10_sub_pixel_avg_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance64x32 =
+        vpx_highbd_10_sub_pixel_avg_variance64x32_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance64x64 =
+      vpx_highbd_10_sub_pixel_avg_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance64x64 =
+        vpx_highbd_10_sub_pixel_avg_variance64x64_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance8x16 =
+      vpx_highbd_10_sub_pixel_avg_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance8x16 =
+        vpx_highbd_10_sub_pixel_avg_variance8x16_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance8x4 =
+      vpx_highbd_10_sub_pixel_avg_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance8x4 =
+        vpx_highbd_10_sub_pixel_avg_variance8x4_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance8x8 =
+      vpx_highbd_10_sub_pixel_avg_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance8x8 =
+        vpx_highbd_10_sub_pixel_avg_variance8x8_sse2;
+  vpx_highbd_10_sub_pixel_variance16x16 =
+      vpx_highbd_10_sub_pixel_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance16x16 =
+        vpx_highbd_10_sub_pixel_variance16x16_sse2;
+  vpx_highbd_10_sub_pixel_variance16x32 =
+      vpx_highbd_10_sub_pixel_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance16x32 =
+        vpx_highbd_10_sub_pixel_variance16x32_sse2;
+  vpx_highbd_10_sub_pixel_variance16x8 = vpx_highbd_10_sub_pixel_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance16x8 =
+        vpx_highbd_10_sub_pixel_variance16x8_sse2;
+  vpx_highbd_10_sub_pixel_variance32x16 =
+      vpx_highbd_10_sub_pixel_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance32x16 =
+        vpx_highbd_10_sub_pixel_variance32x16_sse2;
+  vpx_highbd_10_sub_pixel_variance32x32 =
+      vpx_highbd_10_sub_pixel_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance32x32 =
+        vpx_highbd_10_sub_pixel_variance32x32_sse2;
+  vpx_highbd_10_sub_pixel_variance32x64 =
+      vpx_highbd_10_sub_pixel_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance32x64 =
+        vpx_highbd_10_sub_pixel_variance32x64_sse2;
+  vpx_highbd_10_sub_pixel_variance64x32 =
+      vpx_highbd_10_sub_pixel_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance64x32 =
+        vpx_highbd_10_sub_pixel_variance64x32_sse2;
+  vpx_highbd_10_sub_pixel_variance64x64 =
+      vpx_highbd_10_sub_pixel_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance64x64 =
+        vpx_highbd_10_sub_pixel_variance64x64_sse2;
+  vpx_highbd_10_sub_pixel_variance8x16 = vpx_highbd_10_sub_pixel_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance8x16 =
+        vpx_highbd_10_sub_pixel_variance8x16_sse2;
+  vpx_highbd_10_sub_pixel_variance8x4 = vpx_highbd_10_sub_pixel_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance8x4 =
+        vpx_highbd_10_sub_pixel_variance8x4_sse2;
+  vpx_highbd_10_sub_pixel_variance8x8 = vpx_highbd_10_sub_pixel_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance8x8 =
+        vpx_highbd_10_sub_pixel_variance8x8_sse2;
+  vpx_highbd_10_variance16x16 = vpx_highbd_10_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance16x16 = vpx_highbd_10_variance16x16_sse2;
+  vpx_highbd_10_variance16x32 = vpx_highbd_10_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance16x32 = vpx_highbd_10_variance16x32_sse2;
+  vpx_highbd_10_variance16x8 = vpx_highbd_10_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance16x8 = vpx_highbd_10_variance16x8_sse2;
+  vpx_highbd_10_variance32x16 = vpx_highbd_10_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance32x16 = vpx_highbd_10_variance32x16_sse2;
+  vpx_highbd_10_variance32x32 = vpx_highbd_10_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance32x32 = vpx_highbd_10_variance32x32_sse2;
+  vpx_highbd_10_variance32x64 = vpx_highbd_10_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance32x64 = vpx_highbd_10_variance32x64_sse2;
+  vpx_highbd_10_variance64x32 = vpx_highbd_10_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance64x32 = vpx_highbd_10_variance64x32_sse2;
+  vpx_highbd_10_variance64x64 = vpx_highbd_10_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance64x64 = vpx_highbd_10_variance64x64_sse2;
+  vpx_highbd_10_variance8x16 = vpx_highbd_10_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance8x16 = vpx_highbd_10_variance8x16_sse2;
+  vpx_highbd_10_variance8x8 = vpx_highbd_10_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance8x8 = vpx_highbd_10_variance8x8_sse2;
+  vpx_highbd_12_mse16x16 = vpx_highbd_12_mse16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_mse16x16 = vpx_highbd_12_mse16x16_sse2;
+  vpx_highbd_12_mse8x8 = vpx_highbd_12_mse8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_mse8x8 = vpx_highbd_12_mse8x8_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance16x16 =
+      vpx_highbd_12_sub_pixel_avg_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance16x16 =
+        vpx_highbd_12_sub_pixel_avg_variance16x16_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance16x32 =
+      vpx_highbd_12_sub_pixel_avg_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance16x32 =
+        vpx_highbd_12_sub_pixel_avg_variance16x32_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance16x8 =
+      vpx_highbd_12_sub_pixel_avg_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance16x8 =
+        vpx_highbd_12_sub_pixel_avg_variance16x8_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance32x16 =
+      vpx_highbd_12_sub_pixel_avg_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance32x16 =
+        vpx_highbd_12_sub_pixel_avg_variance32x16_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance32x32 =
+      vpx_highbd_12_sub_pixel_avg_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance32x32 =
+        vpx_highbd_12_sub_pixel_avg_variance32x32_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance32x64 =
+      vpx_highbd_12_sub_pixel_avg_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance32x64 =
+        vpx_highbd_12_sub_pixel_avg_variance32x64_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance64x32 =
+      vpx_highbd_12_sub_pixel_avg_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance64x32 =
+        vpx_highbd_12_sub_pixel_avg_variance64x32_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance64x64 =
+      vpx_highbd_12_sub_pixel_avg_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance64x64 =
+        vpx_highbd_12_sub_pixel_avg_variance64x64_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance8x16 =
+      vpx_highbd_12_sub_pixel_avg_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance8x16 =
+        vpx_highbd_12_sub_pixel_avg_variance8x16_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance8x4 =
+      vpx_highbd_12_sub_pixel_avg_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance8x4 =
+        vpx_highbd_12_sub_pixel_avg_variance8x4_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance8x8 =
+      vpx_highbd_12_sub_pixel_avg_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance8x8 =
+        vpx_highbd_12_sub_pixel_avg_variance8x8_sse2;
+  vpx_highbd_12_sub_pixel_variance16x16 =
+      vpx_highbd_12_sub_pixel_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance16x16 =
+        vpx_highbd_12_sub_pixel_variance16x16_sse2;
+  vpx_highbd_12_sub_pixel_variance16x32 =
+      vpx_highbd_12_sub_pixel_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance16x32 =
+        vpx_highbd_12_sub_pixel_variance16x32_sse2;
+  vpx_highbd_12_sub_pixel_variance16x8 = vpx_highbd_12_sub_pixel_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance16x8 =
+        vpx_highbd_12_sub_pixel_variance16x8_sse2;
+  vpx_highbd_12_sub_pixel_variance32x16 =
+      vpx_highbd_12_sub_pixel_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance32x16 =
+        vpx_highbd_12_sub_pixel_variance32x16_sse2;
+  vpx_highbd_12_sub_pixel_variance32x32 =
+      vpx_highbd_12_sub_pixel_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance32x32 =
+        vpx_highbd_12_sub_pixel_variance32x32_sse2;
+  vpx_highbd_12_sub_pixel_variance32x64 =
+      vpx_highbd_12_sub_pixel_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance32x64 =
+        vpx_highbd_12_sub_pixel_variance32x64_sse2;
+  vpx_highbd_12_sub_pixel_variance64x32 =
+      vpx_highbd_12_sub_pixel_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance64x32 =
+        vpx_highbd_12_sub_pixel_variance64x32_sse2;
+  vpx_highbd_12_sub_pixel_variance64x64 =
+      vpx_highbd_12_sub_pixel_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance64x64 =
+        vpx_highbd_12_sub_pixel_variance64x64_sse2;
+  vpx_highbd_12_sub_pixel_variance8x16 = vpx_highbd_12_sub_pixel_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance8x16 =
+        vpx_highbd_12_sub_pixel_variance8x16_sse2;
+  vpx_highbd_12_sub_pixel_variance8x4 = vpx_highbd_12_sub_pixel_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance8x4 =
+        vpx_highbd_12_sub_pixel_variance8x4_sse2;
+  vpx_highbd_12_sub_pixel_variance8x8 = vpx_highbd_12_sub_pixel_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance8x8 =
+        vpx_highbd_12_sub_pixel_variance8x8_sse2;
+  vpx_highbd_12_variance16x16 = vpx_highbd_12_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance16x16 = vpx_highbd_12_variance16x16_sse2;
+  vpx_highbd_12_variance16x32 = vpx_highbd_12_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance16x32 = vpx_highbd_12_variance16x32_sse2;
+  vpx_highbd_12_variance16x8 = vpx_highbd_12_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance16x8 = vpx_highbd_12_variance16x8_sse2;
+  vpx_highbd_12_variance32x16 = vpx_highbd_12_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance32x16 = vpx_highbd_12_variance32x16_sse2;
+  vpx_highbd_12_variance32x32 = vpx_highbd_12_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance32x32 = vpx_highbd_12_variance32x32_sse2;
+  vpx_highbd_12_variance32x64 = vpx_highbd_12_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance32x64 = vpx_highbd_12_variance32x64_sse2;
+  vpx_highbd_12_variance64x32 = vpx_highbd_12_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance64x32 = vpx_highbd_12_variance64x32_sse2;
+  vpx_highbd_12_variance64x64 = vpx_highbd_12_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance64x64 = vpx_highbd_12_variance64x64_sse2;
+  vpx_highbd_12_variance8x16 = vpx_highbd_12_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance8x16 = vpx_highbd_12_variance8x16_sse2;
+  vpx_highbd_12_variance8x8 = vpx_highbd_12_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance8x8 = vpx_highbd_12_variance8x8_sse2;
+  vpx_highbd_8_mse16x16 = vpx_highbd_8_mse16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_mse16x16 = vpx_highbd_8_mse16x16_sse2;
+  vpx_highbd_8_mse8x8 = vpx_highbd_8_mse8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_mse8x8 = vpx_highbd_8_mse8x8_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance16x16 =
+      vpx_highbd_8_sub_pixel_avg_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance16x16 =
+        vpx_highbd_8_sub_pixel_avg_variance16x16_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance16x32 =
+      vpx_highbd_8_sub_pixel_avg_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance16x32 =
+        vpx_highbd_8_sub_pixel_avg_variance16x32_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance16x8 =
+      vpx_highbd_8_sub_pixel_avg_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance16x8 =
+        vpx_highbd_8_sub_pixel_avg_variance16x8_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance32x16 =
+      vpx_highbd_8_sub_pixel_avg_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance32x16 =
+        vpx_highbd_8_sub_pixel_avg_variance32x16_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance32x32 =
+      vpx_highbd_8_sub_pixel_avg_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance32x32 =
+        vpx_highbd_8_sub_pixel_avg_variance32x32_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance32x64 =
+      vpx_highbd_8_sub_pixel_avg_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance32x64 =
+        vpx_highbd_8_sub_pixel_avg_variance32x64_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance64x32 =
+      vpx_highbd_8_sub_pixel_avg_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance64x32 =
+        vpx_highbd_8_sub_pixel_avg_variance64x32_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance64x64 =
+      vpx_highbd_8_sub_pixel_avg_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance64x64 =
+        vpx_highbd_8_sub_pixel_avg_variance64x64_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance8x16 =
+      vpx_highbd_8_sub_pixel_avg_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance8x16 =
+        vpx_highbd_8_sub_pixel_avg_variance8x16_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance8x4 =
+      vpx_highbd_8_sub_pixel_avg_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance8x4 =
+        vpx_highbd_8_sub_pixel_avg_variance8x4_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance8x8 =
+      vpx_highbd_8_sub_pixel_avg_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance8x8 =
+        vpx_highbd_8_sub_pixel_avg_variance8x8_sse2;
+  vpx_highbd_8_sub_pixel_variance16x16 = vpx_highbd_8_sub_pixel_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance16x16 =
+        vpx_highbd_8_sub_pixel_variance16x16_sse2;
+  vpx_highbd_8_sub_pixel_variance16x32 = vpx_highbd_8_sub_pixel_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance16x32 =
+        vpx_highbd_8_sub_pixel_variance16x32_sse2;
+  vpx_highbd_8_sub_pixel_variance16x8 = vpx_highbd_8_sub_pixel_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance16x8 =
+        vpx_highbd_8_sub_pixel_variance16x8_sse2;
+  vpx_highbd_8_sub_pixel_variance32x16 = vpx_highbd_8_sub_pixel_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance32x16 =
+        vpx_highbd_8_sub_pixel_variance32x16_sse2;
+  vpx_highbd_8_sub_pixel_variance32x32 = vpx_highbd_8_sub_pixel_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance32x32 =
+        vpx_highbd_8_sub_pixel_variance32x32_sse2;
+  vpx_highbd_8_sub_pixel_variance32x64 = vpx_highbd_8_sub_pixel_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance32x64 =
+        vpx_highbd_8_sub_pixel_variance32x64_sse2;
+  vpx_highbd_8_sub_pixel_variance64x32 = vpx_highbd_8_sub_pixel_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance64x32 =
+        vpx_highbd_8_sub_pixel_variance64x32_sse2;
+  vpx_highbd_8_sub_pixel_variance64x64 = vpx_highbd_8_sub_pixel_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance64x64 =
+        vpx_highbd_8_sub_pixel_variance64x64_sse2;
+  vpx_highbd_8_sub_pixel_variance8x16 = vpx_highbd_8_sub_pixel_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance8x16 =
+        vpx_highbd_8_sub_pixel_variance8x16_sse2;
+  vpx_highbd_8_sub_pixel_variance8x4 = vpx_highbd_8_sub_pixel_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance8x4 =
+        vpx_highbd_8_sub_pixel_variance8x4_sse2;
+  vpx_highbd_8_sub_pixel_variance8x8 = vpx_highbd_8_sub_pixel_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance8x8 =
+        vpx_highbd_8_sub_pixel_variance8x8_sse2;
+  vpx_highbd_8_variance16x16 = vpx_highbd_8_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance16x16 = vpx_highbd_8_variance16x16_sse2;
+  vpx_highbd_8_variance16x32 = vpx_highbd_8_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance16x32 = vpx_highbd_8_variance16x32_sse2;
+  vpx_highbd_8_variance16x8 = vpx_highbd_8_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance16x8 = vpx_highbd_8_variance16x8_sse2;
+  vpx_highbd_8_variance32x16 = vpx_highbd_8_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance32x16 = vpx_highbd_8_variance32x16_sse2;
+  vpx_highbd_8_variance32x32 = vpx_highbd_8_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance32x32 = vpx_highbd_8_variance32x32_sse2;
+  vpx_highbd_8_variance32x64 = vpx_highbd_8_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance32x64 = vpx_highbd_8_variance32x64_sse2;
+  vpx_highbd_8_variance64x32 = vpx_highbd_8_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance64x32 = vpx_highbd_8_variance64x32_sse2;
+  vpx_highbd_8_variance64x64 = vpx_highbd_8_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance64x64 = vpx_highbd_8_variance64x64_sse2;
+  vpx_highbd_8_variance8x16 = vpx_highbd_8_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance8x16 = vpx_highbd_8_variance8x16_sse2;
+  vpx_highbd_8_variance8x8 = vpx_highbd_8_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance8x8 = vpx_highbd_8_variance8x8_sse2;
+  vpx_highbd_convolve8 = vpx_highbd_convolve8_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8 = vpx_highbd_convolve8_avx2;
+  vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_avx2;
+  vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_avx2;
+  vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_avx2;
+  vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_avx2;
+  vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_avx2;
+  vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_avx2;
+  vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_avx2;
+  vpx_highbd_dc_predictor_16x16 = vpx_highbd_dc_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_dc_predictor_16x16 = vpx_highbd_dc_predictor_16x16_sse2;
+  vpx_highbd_dc_predictor_32x32 = vpx_highbd_dc_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_dc_predictor_32x32 = vpx_highbd_dc_predictor_32x32_sse2;
+  vpx_highbd_dc_predictor_4x4 = vpx_highbd_dc_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_dc_predictor_4x4 = vpx_highbd_dc_predictor_4x4_sse2;
+  vpx_highbd_dc_predictor_8x8 = vpx_highbd_dc_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_dc_predictor_8x8 = vpx_highbd_dc_predictor_8x8_sse2;
+  vpx_highbd_fdct16x16 = vpx_highbd_fdct16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct16x16 = vpx_highbd_fdct16x16_sse2;
+  vpx_highbd_fdct32x32 = vpx_highbd_fdct32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct32x32 = vpx_highbd_fdct32x32_sse2;
+  vpx_highbd_fdct32x32_rd = vpx_highbd_fdct32x32_rd_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct32x32_rd = vpx_highbd_fdct32x32_rd_sse2;
+  vpx_highbd_fdct4x4 = vpx_highbd_fdct4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct4x4 = vpx_highbd_fdct4x4_sse2;
+  vpx_highbd_fdct8x8 = vpx_highbd_fdct8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct8x8 = vpx_highbd_fdct8x8_sse2;
+  vpx_highbd_idct16x16_10_add = vpx_highbd_idct16x16_10_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct16x16_10_add = vpx_highbd_idct16x16_10_add_sse2;
+  vpx_highbd_idct16x16_1_add = vpx_highbd_idct16x16_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct16x16_1_add = vpx_highbd_idct16x16_1_add_sse2;
+  vpx_highbd_idct16x16_256_add = vpx_highbd_idct16x16_256_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct16x16_256_add = vpx_highbd_idct16x16_256_add_sse2;
+  vpx_highbd_idct16x16_38_add = vpx_highbd_idct16x16_38_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct16x16_38_add = vpx_highbd_idct16x16_38_add_sse2;
+  vpx_highbd_idct32x32_1_add = vpx_highbd_idct32x32_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct32x32_1_add = vpx_highbd_idct32x32_1_add_sse2;
+  vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse4_1;
+  vpx_highbd_idct4x4_1_add = vpx_highbd_idct4x4_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct4x4_1_add = vpx_highbd_idct4x4_1_add_sse2;
+  vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse4_1;
+  vpx_highbd_idct8x8_1_add = vpx_highbd_idct8x8_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct8x8_1_add = vpx_highbd_idct8x8_1_add_sse2;
+  vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse4_1;
+  vpx_highbd_lpf_horizontal_16 = vpx_highbd_lpf_horizontal_16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_16 = vpx_highbd_lpf_horizontal_16_sse2;
+  vpx_highbd_lpf_horizontal_16_dual = vpx_highbd_lpf_horizontal_16_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_16_dual = vpx_highbd_lpf_horizontal_16_dual_sse2;
+  vpx_highbd_lpf_horizontal_4 = vpx_highbd_lpf_horizontal_4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_4 = vpx_highbd_lpf_horizontal_4_sse2;
+  vpx_highbd_lpf_horizontal_4_dual = vpx_highbd_lpf_horizontal_4_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_4_dual = vpx_highbd_lpf_horizontal_4_dual_sse2;
+  vpx_highbd_lpf_horizontal_8 = vpx_highbd_lpf_horizontal_8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_8 = vpx_highbd_lpf_horizontal_8_sse2;
+  vpx_highbd_lpf_horizontal_8_dual = vpx_highbd_lpf_horizontal_8_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_8_dual = vpx_highbd_lpf_horizontal_8_dual_sse2;
+  vpx_highbd_lpf_vertical_16 = vpx_highbd_lpf_vertical_16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_16 = vpx_highbd_lpf_vertical_16_sse2;
+  vpx_highbd_lpf_vertical_16_dual = vpx_highbd_lpf_vertical_16_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_16_dual = vpx_highbd_lpf_vertical_16_dual_sse2;
+  vpx_highbd_lpf_vertical_4 = vpx_highbd_lpf_vertical_4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_4 = vpx_highbd_lpf_vertical_4_sse2;
+  vpx_highbd_lpf_vertical_4_dual = vpx_highbd_lpf_vertical_4_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_4_dual = vpx_highbd_lpf_vertical_4_dual_sse2;
+  vpx_highbd_lpf_vertical_8 = vpx_highbd_lpf_vertical_8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_8 = vpx_highbd_lpf_vertical_8_sse2;
+  vpx_highbd_lpf_vertical_8_dual = vpx_highbd_lpf_vertical_8_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_8_dual = vpx_highbd_lpf_vertical_8_dual_sse2;
+  vpx_highbd_quantize_b = vpx_highbd_quantize_b_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_quantize_b = vpx_highbd_quantize_b_sse2;
+  vpx_highbd_quantize_b_32x32 = vpx_highbd_quantize_b_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_quantize_b_32x32 = vpx_highbd_quantize_b_32x32_sse2;
+  vpx_highbd_sad16x16 = vpx_highbd_sad16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x16 = vpx_highbd_sad16x16_sse2;
+  vpx_highbd_sad16x16_avg = vpx_highbd_sad16x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x16_avg = vpx_highbd_sad16x16_avg_sse2;
+  vpx_highbd_sad16x16x4d = vpx_highbd_sad16x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x16x4d = vpx_highbd_sad16x16x4d_sse2;
+  vpx_highbd_sad16x32 = vpx_highbd_sad16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x32 = vpx_highbd_sad16x32_sse2;
+  vpx_highbd_sad16x32_avg = vpx_highbd_sad16x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x32_avg = vpx_highbd_sad16x32_avg_sse2;
+  vpx_highbd_sad16x32x4d = vpx_highbd_sad16x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x32x4d = vpx_highbd_sad16x32x4d_sse2;
+  vpx_highbd_sad16x8 = vpx_highbd_sad16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x8 = vpx_highbd_sad16x8_sse2;
+  vpx_highbd_sad16x8_avg = vpx_highbd_sad16x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x8_avg = vpx_highbd_sad16x8_avg_sse2;
+  vpx_highbd_sad16x8x4d = vpx_highbd_sad16x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x8x4d = vpx_highbd_sad16x8x4d_sse2;
+  vpx_highbd_sad32x16 = vpx_highbd_sad32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x16 = vpx_highbd_sad32x16_sse2;
+  vpx_highbd_sad32x16_avg = vpx_highbd_sad32x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x16_avg = vpx_highbd_sad32x16_avg_sse2;
+  vpx_highbd_sad32x16x4d = vpx_highbd_sad32x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x16x4d = vpx_highbd_sad32x16x4d_sse2;
+  vpx_highbd_sad32x32 = vpx_highbd_sad32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x32 = vpx_highbd_sad32x32_sse2;
+  vpx_highbd_sad32x32_avg = vpx_highbd_sad32x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x32_avg = vpx_highbd_sad32x32_avg_sse2;
+  vpx_highbd_sad32x32x4d = vpx_highbd_sad32x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x32x4d = vpx_highbd_sad32x32x4d_sse2;
+  vpx_highbd_sad32x64 = vpx_highbd_sad32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x64 = vpx_highbd_sad32x64_sse2;
+  vpx_highbd_sad32x64_avg = vpx_highbd_sad32x64_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x64_avg = vpx_highbd_sad32x64_avg_sse2;
+  vpx_highbd_sad32x64x4d = vpx_highbd_sad32x64x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x64x4d = vpx_highbd_sad32x64x4d_sse2;
+  vpx_highbd_sad4x4x4d = vpx_highbd_sad4x4x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad4x4x4d = vpx_highbd_sad4x4x4d_sse2;
+  vpx_highbd_sad4x8x4d = vpx_highbd_sad4x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad4x8x4d = vpx_highbd_sad4x8x4d_sse2;
+  vpx_highbd_sad64x32 = vpx_highbd_sad64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x32 = vpx_highbd_sad64x32_sse2;
+  vpx_highbd_sad64x32_avg = vpx_highbd_sad64x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x32_avg = vpx_highbd_sad64x32_avg_sse2;
+  vpx_highbd_sad64x32x4d = vpx_highbd_sad64x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x32x4d = vpx_highbd_sad64x32x4d_sse2;
+  vpx_highbd_sad64x64 = vpx_highbd_sad64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x64 = vpx_highbd_sad64x64_sse2;
+  vpx_highbd_sad64x64_avg = vpx_highbd_sad64x64_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x64_avg = vpx_highbd_sad64x64_avg_sse2;
+  vpx_highbd_sad64x64x4d = vpx_highbd_sad64x64x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x64x4d = vpx_highbd_sad64x64x4d_sse2;
+  vpx_highbd_sad8x16 = vpx_highbd_sad8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x16 = vpx_highbd_sad8x16_sse2;
+  vpx_highbd_sad8x16_avg = vpx_highbd_sad8x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x16_avg = vpx_highbd_sad8x16_avg_sse2;
+  vpx_highbd_sad8x16x4d = vpx_highbd_sad8x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x16x4d = vpx_highbd_sad8x16x4d_sse2;
+  vpx_highbd_sad8x4 = vpx_highbd_sad8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x4 = vpx_highbd_sad8x4_sse2;
+  vpx_highbd_sad8x4_avg = vpx_highbd_sad8x4_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x4_avg = vpx_highbd_sad8x4_avg_sse2;
+  vpx_highbd_sad8x4x4d = vpx_highbd_sad8x4x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x4x4d = vpx_highbd_sad8x4x4d_sse2;
+  vpx_highbd_sad8x8 = vpx_highbd_sad8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x8 = vpx_highbd_sad8x8_sse2;
+  vpx_highbd_sad8x8_avg = vpx_highbd_sad8x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x8_avg = vpx_highbd_sad8x8_avg_sse2;
+  vpx_highbd_sad8x8x4d = vpx_highbd_sad8x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x8x4d = vpx_highbd_sad8x8x4d_sse2;
+  vpx_highbd_tm_predictor_16x16 = vpx_highbd_tm_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_tm_predictor_16x16 = vpx_highbd_tm_predictor_16x16_sse2;
+  vpx_highbd_tm_predictor_32x32 = vpx_highbd_tm_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_tm_predictor_32x32 = vpx_highbd_tm_predictor_32x32_sse2;
+  vpx_highbd_tm_predictor_4x4 = vpx_highbd_tm_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_tm_predictor_4x4 = vpx_highbd_tm_predictor_4x4_sse2;
+  vpx_highbd_tm_predictor_8x8 = vpx_highbd_tm_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_tm_predictor_8x8 = vpx_highbd_tm_predictor_8x8_sse2;
+  vpx_highbd_v_predictor_16x16 = vpx_highbd_v_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_v_predictor_16x16 = vpx_highbd_v_predictor_16x16_sse2;
+  vpx_highbd_v_predictor_32x32 = vpx_highbd_v_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_v_predictor_32x32 = vpx_highbd_v_predictor_32x32_sse2;
+  vpx_highbd_v_predictor_4x4 = vpx_highbd_v_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_v_predictor_4x4 = vpx_highbd_v_predictor_4x4_sse2;
+  vpx_highbd_v_predictor_8x8 = vpx_highbd_v_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_v_predictor_8x8 = vpx_highbd_v_predictor_8x8_sse2;
+  vpx_idct16x16_10_add = vpx_idct16x16_10_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct16x16_10_add = vpx_idct16x16_10_add_sse2;
+  vpx_idct16x16_1_add = vpx_idct16x16_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct16x16_1_add = vpx_idct16x16_1_add_sse2;
+  vpx_idct16x16_256_add = vpx_idct16x16_256_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct16x16_256_add = vpx_idct16x16_256_add_sse2;
+  vpx_idct16x16_38_add = vpx_idct16x16_38_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct16x16_38_add = vpx_idct16x16_38_add_sse2;
+  vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_sse2;
+  vpx_idct32x32_135_add = vpx_idct32x32_135_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct32x32_135_add = vpx_idct32x32_1024_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct32x32_135_add = vpx_idct32x32_135_add_ssse3;
+  vpx_idct32x32_1_add = vpx_idct32x32_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct32x32_1_add = vpx_idct32x32_1_add_sse2;
+  vpx_idct32x32_34_add = vpx_idct32x32_34_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct32x32_34_add = vpx_idct32x32_34_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct32x32_34_add = vpx_idct32x32_34_add_ssse3;
+  vpx_idct4x4_16_add = vpx_idct4x4_16_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct4x4_16_add = vpx_idct4x4_16_add_sse2;
+  vpx_idct4x4_1_add = vpx_idct4x4_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct4x4_1_add = vpx_idct4x4_1_add_sse2;
+  vpx_idct8x8_12_add = vpx_idct8x8_12_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct8x8_12_add = vpx_idct8x8_12_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct8x8_12_add = vpx_idct8x8_12_add_ssse3;
+  vpx_idct8x8_1_add = vpx_idct8x8_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct8x8_1_add = vpx_idct8x8_1_add_sse2;
+  vpx_idct8x8_64_add = vpx_idct8x8_64_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct8x8_64_add = vpx_idct8x8_64_add_sse2;
+  vpx_int_pro_col = vpx_int_pro_col_c;
+  if (flags & HAS_SSE2)
+    vpx_int_pro_col = vpx_int_pro_col_sse2;
+  vpx_int_pro_row = vpx_int_pro_row_c;
+  if (flags & HAS_SSE2)
+    vpx_int_pro_row = vpx_int_pro_row_sse2;
+  vpx_iwht4x4_16_add = vpx_iwht4x4_16_add_c;
+  if (flags & HAS_SSE2)
+    vpx_iwht4x4_16_add = vpx_iwht4x4_16_add_sse2;
+  vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_avx2;
+  vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_sse2;
+  if (flags & HAS_AVX2)
+    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_avx2;
+  vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_sse2;
+  vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_sse2;
+  vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_sse2;
+  vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_sse2;
+  vpx_lpf_vertical_16 = vpx_lpf_vertical_16_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_16 = vpx_lpf_vertical_16_sse2;
+  vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_sse2;
+  vpx_lpf_vertical_4 = vpx_lpf_vertical_4_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_4 = vpx_lpf_vertical_4_sse2;
+  vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_sse2;
+  vpx_lpf_vertical_8 = vpx_lpf_vertical_8_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_8 = vpx_lpf_vertical_8_sse2;
+  vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_sse2;
+  vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_c;
+  if (flags & HAS_SSE2)
+    vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_sse2;
+  vpx_mbpost_proc_down = vpx_mbpost_proc_down_c;
+  if (flags & HAS_SSE2)
+    vpx_mbpost_proc_down = vpx_mbpost_proc_down_sse2;
+  vpx_minmax_8x8 = vpx_minmax_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_minmax_8x8 = vpx_minmax_8x8_sse2;
+  vpx_mse16x16 = vpx_mse16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_mse16x16 = vpx_mse16x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_mse16x16 = vpx_mse16x16_avx2;
+  vpx_mse16x8 = vpx_mse16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_mse16x8 = vpx_mse16x8_sse2;
+  vpx_mse8x16 = vpx_mse8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_mse8x16 = vpx_mse8x16_sse2;
+  vpx_mse8x8 = vpx_mse8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_mse8x8 = vpx_mse8x8_sse2;
+  vpx_plane_add_noise = vpx_plane_add_noise_c;
+  if (flags & HAS_SSE2)
+    vpx_plane_add_noise = vpx_plane_add_noise_sse2;
+  vpx_post_proc_down_and_across_mb_row = vpx_post_proc_down_and_across_mb_row_c;
+  if (flags & HAS_SSE2)
+    vpx_post_proc_down_and_across_mb_row =
+        vpx_post_proc_down_and_across_mb_row_sse2;
+  vpx_quantize_b = vpx_quantize_b_c;
+  if (flags & HAS_SSE2)
+    vpx_quantize_b = vpx_quantize_b_sse2;
+  vpx_sad16x16 = vpx_sad16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x16 = vpx_sad16x16_sse2;
+  vpx_sad16x16_avg = vpx_sad16x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x16_avg = vpx_sad16x16_avg_sse2;
+  vpx_sad16x16x3 = vpx_sad16x16x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad16x16x3 = vpx_sad16x16x3_sse3;
+  if (flags & HAS_SSSE3)
+    vpx_sad16x16x3 = vpx_sad16x16x3_ssse3;
+  vpx_sad16x16x4d = vpx_sad16x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x16x4d = vpx_sad16x16x4d_sse2;
+  vpx_sad16x16x8 = vpx_sad16x16x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad16x16x8 = vpx_sad16x16x8_sse4_1;
+  vpx_sad16x32 = vpx_sad16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x32 = vpx_sad16x32_sse2;
+  vpx_sad16x32_avg = vpx_sad16x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x32_avg = vpx_sad16x32_avg_sse2;
+  vpx_sad16x32x4d = vpx_sad16x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x32x4d = vpx_sad16x32x4d_sse2;
+  vpx_sad16x8 = vpx_sad16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x8 = vpx_sad16x8_sse2;
+  vpx_sad16x8_avg = vpx_sad16x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x8_avg = vpx_sad16x8_avg_sse2;
+  vpx_sad16x8x3 = vpx_sad16x8x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad16x8x3 = vpx_sad16x8x3_sse3;
+  if (flags & HAS_SSSE3)
+    vpx_sad16x8x3 = vpx_sad16x8x3_ssse3;
+  vpx_sad16x8x4d = vpx_sad16x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x8x4d = vpx_sad16x8x4d_sse2;
+  vpx_sad16x8x8 = vpx_sad16x8x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad16x8x8 = vpx_sad16x8x8_sse4_1;
+  vpx_sad32x16 = vpx_sad32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x16 = vpx_sad32x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x16 = vpx_sad32x16_avx2;
+  vpx_sad32x16_avg = vpx_sad32x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x16_avg = vpx_sad32x16_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x16_avg = vpx_sad32x16_avg_avx2;
+  vpx_sad32x16x4d = vpx_sad32x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x16x4d = vpx_sad32x16x4d_sse2;
+  vpx_sad32x32 = vpx_sad32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x32 = vpx_sad32x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32 = vpx_sad32x32_avx2;
+  vpx_sad32x32_avg = vpx_sad32x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x32_avg = vpx_sad32x32_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32_avg = vpx_sad32x32_avg_avx2;
+  vpx_sad32x32x4d = vpx_sad32x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x32x4d = vpx_sad32x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32x4d = vpx_sad32x32x4d_avx2;
+  vpx_sad32x64 = vpx_sad32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x64 = vpx_sad32x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x64 = vpx_sad32x64_avx2;
+  vpx_sad32x64_avg = vpx_sad32x64_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x64_avg = vpx_sad32x64_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x64_avg = vpx_sad32x64_avg_avx2;
+  vpx_sad32x64x4d = vpx_sad32x64x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x64x4d = vpx_sad32x64x4d_sse2;
+  vpx_sad4x4 = vpx_sad4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x4 = vpx_sad4x4_sse2;
+  vpx_sad4x4_avg = vpx_sad4x4_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x4_avg = vpx_sad4x4_avg_sse2;
+  vpx_sad4x4x3 = vpx_sad4x4x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad4x4x3 = vpx_sad4x4x3_sse3;
+  vpx_sad4x4x4d = vpx_sad4x4x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x4x4d = vpx_sad4x4x4d_sse2;
+  vpx_sad4x4x8 = vpx_sad4x4x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad4x4x8 = vpx_sad4x4x8_sse4_1;
+  vpx_sad4x8 = vpx_sad4x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x8 = vpx_sad4x8_sse2;
+  vpx_sad4x8_avg = vpx_sad4x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x8_avg = vpx_sad4x8_avg_sse2;
+  vpx_sad4x8x4d = vpx_sad4x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x8x4d = vpx_sad4x8x4d_sse2;
+  vpx_sad64x32 = vpx_sad64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x32 = vpx_sad64x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x32 = vpx_sad64x32_avx2;
+  vpx_sad64x32_avg = vpx_sad64x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x32_avg = vpx_sad64x32_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x32_avg = vpx_sad64x32_avg_avx2;
+  vpx_sad64x32x4d = vpx_sad64x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x32x4d = vpx_sad64x32x4d_sse2;
+  vpx_sad64x64 = vpx_sad64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x64 = vpx_sad64x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64 = vpx_sad64x64_avx2;
+  vpx_sad64x64_avg = vpx_sad64x64_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x64_avg = vpx_sad64x64_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64_avg = vpx_sad64x64_avg_avx2;
+  vpx_sad64x64x4d = vpx_sad64x64x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x64x4d = vpx_sad64x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64x4d = vpx_sad64x64x4d_avx2;
+  vpx_sad8x16 = vpx_sad8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x16 = vpx_sad8x16_sse2;
+  vpx_sad8x16_avg = vpx_sad8x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x16_avg = vpx_sad8x16_avg_sse2;
+  vpx_sad8x16x3 = vpx_sad8x16x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad8x16x3 = vpx_sad8x16x3_sse3;
+  vpx_sad8x16x4d = vpx_sad8x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x16x4d = vpx_sad8x16x4d_sse2;
+  vpx_sad8x16x8 = vpx_sad8x16x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad8x16x8 = vpx_sad8x16x8_sse4_1;
+  vpx_sad8x4 = vpx_sad8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x4 = vpx_sad8x4_sse2;
+  vpx_sad8x4_avg = vpx_sad8x4_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x4_avg = vpx_sad8x4_avg_sse2;
+  vpx_sad8x4x4d = vpx_sad8x4x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x4x4d = vpx_sad8x4x4d_sse2;
+  vpx_sad8x8 = vpx_sad8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x8 = vpx_sad8x8_sse2;
+  vpx_sad8x8_avg = vpx_sad8x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x8_avg = vpx_sad8x8_avg_sse2;
+  vpx_sad8x8x3 = vpx_sad8x8x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad8x8x3 = vpx_sad8x8x3_sse3;
+  vpx_sad8x8x4d = vpx_sad8x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x8x4d = vpx_sad8x8x4d_sse2;
+  vpx_sad8x8x8 = vpx_sad8x8x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad8x8x8 = vpx_sad8x8x8_sse4_1;
+  vpx_satd = vpx_satd_c;
+  if (flags & HAS_SSE2)
+    vpx_satd = vpx_satd_sse2;
+  vpx_scaled_2d = vpx_scaled_2d_c;
+  if (flags & HAS_SSSE3)
+    vpx_scaled_2d = vpx_scaled_2d_ssse3;
+  vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_ssse3;
+  vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_ssse3;
+  vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_ssse3;
+  vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_ssse3;
+  vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_avx2;
+  vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_ssse3;
+  vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_ssse3;
+  vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_ssse3;
+  vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_ssse3;
+  vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_avx2;
+  vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_ssse3;
+  vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_ssse3;
+  vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_ssse3;
+  vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_ssse3;
+  vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_ssse3;
+  vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_ssse3;
+  vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_ssse3;
+  vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_avx2;
+  vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_ssse3;
+  vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_ssse3;
+  vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_ssse3;
+  vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_ssse3;
+  vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_avx2;
+  vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_ssse3;
+  vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_ssse3;
+  vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_ssse3;
+  vpx_subtract_block = vpx_subtract_block_c;
+  if (flags & HAS_SSE2)
+    vpx_subtract_block = vpx_subtract_block_sse2;
+  vpx_sum_squares_2d_i16 = vpx_sum_squares_2d_i16_c;
+  if (flags & HAS_SSE2)
+    vpx_sum_squares_2d_i16 = vpx_sum_squares_2d_i16_sse2;
+  vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_sse2;
+  vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_sse2;
+  vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_sse2;
+  vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_sse2;
+  vpx_v_predictor_16x16 = vpx_v_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_v_predictor_16x16 = vpx_v_predictor_16x16_sse2;
+  vpx_v_predictor_32x32 = vpx_v_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_v_predictor_32x32 = vpx_v_predictor_32x32_sse2;
+  vpx_v_predictor_4x4 = vpx_v_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_v_predictor_4x4 = vpx_v_predictor_4x4_sse2;
+  vpx_v_predictor_8x8 = vpx_v_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_v_predictor_8x8 = vpx_v_predictor_8x8_sse2;
+  vpx_variance16x16 = vpx_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_variance16x16 = vpx_variance16x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance16x16 = vpx_variance16x16_avx2;
+  vpx_variance16x32 = vpx_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_variance16x32 = vpx_variance16x32_sse2;
+  vpx_variance16x8 = vpx_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_variance16x8 = vpx_variance16x8_sse2;
+  vpx_variance32x16 = vpx_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_variance32x16 = vpx_variance32x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance32x16 = vpx_variance32x16_avx2;
+  vpx_variance32x32 = vpx_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_variance32x32 = vpx_variance32x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance32x32 = vpx_variance32x32_avx2;
+  vpx_variance32x64 = vpx_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_variance32x64 = vpx_variance32x64_sse2;
+  vpx_variance4x4 = vpx_variance4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_variance4x4 = vpx_variance4x4_sse2;
+  vpx_variance4x8 = vpx_variance4x8_c;
+  if (flags & HAS_SSE2)
+    vpx_variance4x8 = vpx_variance4x8_sse2;
+  vpx_variance64x32 = vpx_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_variance64x32 = vpx_variance64x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance64x32 = vpx_variance64x32_avx2;
+  vpx_variance64x64 = vpx_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_variance64x64 = vpx_variance64x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance64x64 = vpx_variance64x64_avx2;
+  vpx_variance8x16 = vpx_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_variance8x16 = vpx_variance8x16_sse2;
+  vpx_variance8x4 = vpx_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_variance8x4 = vpx_variance8x4_sse2;
+  vpx_variance8x8 = vpx_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_variance8x8 = vpx_variance8x8_sse2;
+  vpx_vector_var = vpx_vector_var_c;
+  if (flags & HAS_SSE2)
+    vpx_vector_var = vpx_vector_var_sse2;
 }
 #endif
 

third_party/libvpx/source/config/mac/ia32/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/mac/ia32/vpx_scale_rtcd.h b/third_party/libvpx/source/config/mac/ia32/vpx_scale_rtcd.h
index ada0f6d..0ba352cb 100644
--- a/third_party/libvpx/source/config/mac/ia32/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/mac/ia32/vpx_scale_rtcd.h
@@ -13,55 +13,81 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/mac/x64/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/mac/x64/vp8_rtcd.h b/third_party/libvpx/source/config/mac/x64/vp8_rtcd.h
index 8dcc9eb..baafe8be 100644
--- a/third_party/libvpx/source/config/mac/x64/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/mac/x64/vp8_rtcd.h
@@ -26,230 +26,647 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict16x16)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+void vp8_bilinear_predict16x16_sse2(unsigned char* src,
+                                    int src_pitch,
+                                    int xofst,
+                                    int yofst,
+                                    unsigned char* dst,
+                                    int dst_pitch);
+void vp8_bilinear_predict16x16_ssse3(unsigned char* src,
+                                     int src_pitch,
+                                     int xofst,
+                                     int yofst,
+                                     unsigned char* dst,
+                                     int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict16x16)(unsigned char* src,
+                                              int src_pitch,
+                                              int xofst,
+                                              int yofst,
+                                              unsigned char* dst,
+                                              int dst_pitch);
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict4x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict4x4_mmx(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
 #define vp8_bilinear_predict4x4 vp8_bilinear_predict4x4_mmx
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x4_mmx(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
 #define vp8_bilinear_predict8x4 vp8_bilinear_predict8x4_mmx
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict8x8)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x8_sse2(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+void vp8_bilinear_predict8x8_ssse3(unsigned char* src,
+                                   int src_pitch,
+                                   int xofst,
+                                   int yofst,
+                                   unsigned char* dst,
+                                   int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict8x8)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
-int vp8_block_error_sse2(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
+int vp8_block_error_sse2(short* coeff, short* dqcoeff);
 #define vp8_block_error vp8_block_error_sse2
 
-void vp8_copy32xn_c(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-void vp8_copy32xn_sse2(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-void vp8_copy32xn_sse3(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-RTCD_EXTERN void (*vp8_copy32xn)(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
+void vp8_copy32xn_c(const unsigned char* src_ptr,
+                    int source_stride,
+                    unsigned char* dst_ptr,
+                    int dst_stride,
+                    int n);
+void vp8_copy32xn_sse2(const unsigned char* src_ptr,
+                       int source_stride,
+                       unsigned char* dst_ptr,
+                       int dst_stride,
+                       int n);
+void vp8_copy32xn_sse3(const unsigned char* src_ptr,
+                       int source_stride,
+                       unsigned char* dst_ptr,
+                       int dst_stride,
+                       int n);
+RTCD_EXTERN void (*vp8_copy32xn)(const unsigned char* src_ptr,
+                                 int source_stride,
+                                 unsigned char* dst_ptr,
+                                 int dst_stride,
+                                 int n);
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem16x16_sse2(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+void vp8_copy_mem16x16_sse2(unsigned char* src,
+                            int src_pitch,
+                            unsigned char* dst,
+                            int dst_pitch);
 #define vp8_copy_mem16x16 vp8_copy_mem16x16_sse2
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x4_mmx(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x4_mmx(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
 #define vp8_copy_mem8x4 vp8_copy_mem8x4_mmx
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x8_mmx(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x8_mmx(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
 #define vp8_copy_mem8x8 vp8_copy_mem8x8_mmx
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-void vp8_dc_only_idct_add_mmx(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_dc_only_idct_add_mmx(short input,
+                              unsigned char* pred,
+                              int pred_stride,
+                              unsigned char* dst,
+                              int dst_stride);
 #define vp8_dc_only_idct_add vp8_dc_only_idct_add_mmx
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_sse2(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
+int vp8_denoiser_filter_sse2(unsigned char* mc_running_avg_y,
+                             int mc_avg_y_stride,
+                             unsigned char* running_avg_y,
+                             int avg_y_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
 #define vp8_denoiser_filter vp8_denoiser_filter_sse2
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_uv_sse2(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+int vp8_denoiser_filter_uv_sse2(unsigned char* mc_running_avg,
+                                int mc_avg_stride,
+                                unsigned char* running_avg,
+                                int avg_stride,
+                                unsigned char* sig,
+                                int sig_stride,
+                                unsigned int motion_magnitude,
+                                int increase_denoising);
 #define vp8_denoiser_filter_uv vp8_denoiser_filter_uv_sse2
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
-void vp8_dequant_idct_add_mmx(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
+void vp8_dequant_idct_add_mmx(short* input,
+                              short* dq,
+                              unsigned char* output,
+                              int stride);
 #define vp8_dequant_idct_add vp8_dequant_idct_add_mmx
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-void vp8_dequant_idct_add_uv_block_sse2(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
+void vp8_dequant_idct_add_uv_block_sse2(short* q,
+                                        short* dq,
+                                        unsigned char* dst_u,
+                                        unsigned char* dst_v,
+                                        int stride,
+                                        char* eobs);
 #define vp8_dequant_idct_add_uv_block vp8_dequant_idct_add_uv_block_sse2
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-void vp8_dequant_idct_add_y_block_sse2(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
+void vp8_dequant_idct_add_y_block_sse2(short* q,
+                                       short* dq,
+                                       unsigned char* dst,
+                                       int stride,
+                                       char* eobs);
 #define vp8_dequant_idct_add_y_block vp8_dequant_idct_add_y_block_sse2
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
-void vp8_dequantize_b_mmx(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
+void vp8_dequantize_b_mmx(struct blockd*, short* dqc);
 #define vp8_dequantize_b vp8_dequantize_b_mmx
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_diamond_search_sadx4(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
+int vp8_diamond_search_sadx4(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
 #define vp8_diamond_search_sad vp8_diamond_search_sadx4
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
-void vp8_fast_quantize_b_sse2(struct block *, struct blockd *);
-void vp8_fast_quantize_b_ssse3(struct block *, struct blockd *);
-RTCD_EXTERN void (*vp8_fast_quantize_b)(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
+void vp8_fast_quantize_b_sse2(struct block*, struct blockd*);
+void vp8_fast_quantize_b_ssse3(struct block*, struct blockd*);
+RTCD_EXTERN void (*vp8_fast_quantize_b)(struct block*, struct blockd*);
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-void vp8_filter_by_weight16x16_sse2(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
+void vp8_filter_by_weight16x16_sse2(unsigned char* src,
+                                    int src_stride,
+                                    unsigned char* dst,
+                                    int dst_stride,
+                                    int src_weight);
 #define vp8_filter_by_weight16x16 vp8_filter_by_weight16x16_sse2
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-void vp8_filter_by_weight8x8_sse2(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
+void vp8_filter_by_weight8x8_sse2(unsigned char* src,
+                                  int src_stride,
+                                  unsigned char* dst,
+                                  int dst_stride,
+                                  int src_weight);
 #define vp8_filter_by_weight8x8 vp8_filter_by_weight8x8_sse2
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_full_search_sadx3(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_full_search_sadx8(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-RTCD_EXTERN int (*vp8_full_search_sad)(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+int vp8_full_search_sadx3(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+int vp8_full_search_sadx8(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+RTCD_EXTERN int (*vp8_full_search_sad)(struct macroblock* x,
+                                       struct block* b,
+                                       struct blockd* d,
+                                       union int_mv* ref_mv,
+                                       int sad_per_bit,
+                                       int distance,
+                                       struct variance_vtable* fn_ptr,
+                                       int* mvcost[2],
+                                       union int_mv* center_mv);
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bh_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bh_sse2(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
 #define vp8_loop_filter_bh vp8_loop_filter_bh_sse2
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bv_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bv_sse2(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
 #define vp8_loop_filter_bv vp8_loop_filter_bv_sse2
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbh_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbh_sse2(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbh vp8_loop_filter_mbh_sse2
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbv_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbv_sse2(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbv vp8_loop_filter_mbv_sse2
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bhs_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bhs_sse2(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_bh vp8_loop_filter_bhs_sse2
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bvs_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bvs_sse2(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_bv vp8_loop_filter_bvs_sse2
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_simple_horizontal_edge_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
+void vp8_loop_filter_simple_horizontal_edge_sse2(unsigned char* y,
+                                                 int ystride,
+                                                 const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbh vp8_loop_filter_simple_horizontal_edge_sse2
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_simple_vertical_edge_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
+void vp8_loop_filter_simple_vertical_edge_sse2(unsigned char* y,
+                                               int ystride,
+                                               const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbv vp8_loop_filter_simple_vertical_edge_sse2
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
-int vp8_mbblock_error_sse2(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
+int vp8_mbblock_error_sse2(struct macroblock* mb, int dc);
 #define vp8_mbblock_error vp8_mbblock_error_sse2
 
-int vp8_mbuverror_c(struct macroblock *mb);
-int vp8_mbuverror_sse2(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
+int vp8_mbuverror_sse2(struct macroblock* mb);
 #define vp8_mbuverror vp8_mbuverror_sse2
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_refining_search_sadx4(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
+int vp8_refining_search_sadx4(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
 #define vp8_refining_search_sad vp8_refining_search_sadx4
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
-void vp8_regular_quantize_b_sse2(struct block *, struct blockd *);
-void vp8_regular_quantize_b_sse4_1(struct block *, struct blockd *);
-RTCD_EXTERN void (*vp8_regular_quantize_b)(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
+void vp8_regular_quantize_b_sse2(struct block*, struct blockd*);
+void vp8_regular_quantize_b_sse4_1(struct block*, struct blockd*);
+RTCD_EXTERN void (*vp8_regular_quantize_b)(struct block*, struct blockd*);
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct4x4_sse2(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct4x4_sse2(short* input, short* output, int pitch);
 #define vp8_short_fdct4x4 vp8_short_fdct4x4_sse2
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct8x4_sse2(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct8x4_sse2(short* input, short* output, int pitch);
 #define vp8_short_fdct8x4 vp8_short_fdct8x4_sse2
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-void vp8_short_idct4x4llm_mmx(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_short_idct4x4llm_mmx(short* input,
+                              unsigned char* pred,
+                              int pitch,
+                              unsigned char* dst,
+                              int dst_stride);
 #define vp8_short_idct4x4llm vp8_short_idct4x4llm_mmx
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
-void vp8_short_inv_walsh4x4_sse2(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
+void vp8_short_inv_walsh4x4_sse2(short* input, short* output);
 #define vp8_short_inv_walsh4x4 vp8_short_inv_walsh4x4_sse2
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
-void vp8_short_walsh4x4_sse2(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
+void vp8_short_walsh4x4_sse2(short* input, short* output, int pitch);
 #define vp8_short_walsh4x4 vp8_short_walsh4x4_sse2
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict16x16)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict16x16_sse2(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+void vp8_sixtap_predict16x16_ssse3(unsigned char* src,
+                                   int src_pitch,
+                                   int xofst,
+                                   int yofst,
+                                   unsigned char* dst,
+                                   int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict16x16)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict4x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict4x4_mmx(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict4x4_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict4x4)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict8x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x4_sse2(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+void vp8_sixtap_predict8x4_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict8x4)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict8x8)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x8_sse2(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+void vp8_sixtap_predict8x8_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict8x8)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
 void vp8_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_sse2;
-    if (flags & HAS_SSSE3) vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_ssse3;
-    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_sse2;
-    if (flags & HAS_SSSE3) vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_ssse3;
-    vp8_copy32xn = vp8_copy32xn_sse2;
-    if (flags & HAS_SSE3) vp8_copy32xn = vp8_copy32xn_sse3;
-    vp8_fast_quantize_b = vp8_fast_quantize_b_sse2;
-    if (flags & HAS_SSSE3) vp8_fast_quantize_b = vp8_fast_quantize_b_ssse3;
-    vp8_full_search_sad = vp8_full_search_sad_c;
-    if (flags & HAS_SSE3) vp8_full_search_sad = vp8_full_search_sadx3;
-    if (flags & HAS_SSE4_1) vp8_full_search_sad = vp8_full_search_sadx8;
-    vp8_regular_quantize_b = vp8_regular_quantize_b_sse2;
-    if (flags & HAS_SSE4_1) vp8_regular_quantize_b = vp8_regular_quantize_b_sse4_1;
-    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_ssse3;
-    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_mmx;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_ssse3;
-    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_ssse3;
-    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_ssse3;
+  vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_ssse3;
+  vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_ssse3;
+  vp8_copy32xn = vp8_copy32xn_sse2;
+  if (flags & HAS_SSE3)
+    vp8_copy32xn = vp8_copy32xn_sse3;
+  vp8_fast_quantize_b = vp8_fast_quantize_b_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_fast_quantize_b = vp8_fast_quantize_b_ssse3;
+  vp8_full_search_sad = vp8_full_search_sad_c;
+  if (flags & HAS_SSE3)
+    vp8_full_search_sad = vp8_full_search_sadx3;
+  if (flags & HAS_SSE4_1)
+    vp8_full_search_sad = vp8_full_search_sadx8;
+  vp8_regular_quantize_b = vp8_regular_quantize_b_sse2;
+  if (flags & HAS_SSE4_1)
+    vp8_regular_quantize_b = vp8_regular_quantize_b_sse4_1;
+  vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_ssse3;
+  vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_mmx;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_ssse3;
+  vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_ssse3;
+  vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_ssse3;
 }
 #endif
 

third_party/libvpx/source/config/mac/x64/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/mac/x64/vp9_rtcd.h b/third_party/libvpx/source/config/mac/x64/vp9_rtcd.h
index 415d6be..b985873 100644
--- a/third_party/libvpx/source/config/mac/x64/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/mac/x64/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,147 +30,474 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-int64_t vp9_block_error_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-int64_t vp9_block_error_avx2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-RTCD_EXTERN int64_t (*vp9_block_error)(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
+int64_t vp9_block_error_sse2(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             intptr_t block_size,
+                             int64_t* ssz);
+int64_t vp9_block_error_avx2(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             intptr_t block_size,
+                             int64_t* ssz);
+RTCD_EXTERN int64_t (*vp9_block_error)(const tran_low_t* coeff,
+                                       const tran_low_t* dqcoeff,
+                                       intptr_t block_size,
+                                       int64_t* ssz);
 
-int64_t vp9_block_error_fp_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
-int64_t vp9_block_error_fp_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             int block_size);
+int64_t vp9_block_error_fp_sse2(const tran_low_t* coeff,
+                                const tran_low_t* dqcoeff,
+                                int block_size);
 #define vp9_block_error_fp vp9_block_error_fp_sse2
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-int vp9_denoiser_filter_sse2(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
+int vp9_denoiser_filter_sse2(const uint8_t* sig,
+                             int sig_stride,
+                             const uint8_t* mc_avg,
+                             int mc_avg_stride,
+                             uint8_t* avg,
+                             int avg_stride,
+                             int increase_denoising,
+                             BLOCK_SIZE bs,
+                             int motion_magnitude);
 #define vp9_denoiser_filter vp9_denoiser_filter_sse2
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
-int vp9_diamond_search_sad_avx(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
-RTCD_EXTERN int (*vp9_diamond_search_sad)(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
+int vp9_diamond_search_sad_avx(const struct macroblock* x,
+                               const struct search_site_config* cfg,
+                               struct mv* ref_mv,
+                               struct mv* best_mv,
+                               int search_param,
+                               int sad_per_bit,
+                               int* num00,
+                               const struct vp9_variance_vtable* fn_ptr,
+                               const struct mv* center_mv);
+RTCD_EXTERN int (*vp9_diamond_search_sad)(
+    const struct macroblock* x,
+    const struct search_site_config* cfg,
+    struct mv* ref_mv,
+    struct mv* best_mv,
+    int search_param,
+    int sad_per_bit,
+    int* num00,
+    const struct vp9_variance_vtable* fn_ptr,
+    const struct mv* center_mv);
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_fdct8x8_quant_ssse3(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_fdct8x8_quant)(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+void vp9_fdct8x8_quant_ssse3(const int16_t* input,
+                             int stride,
+                             tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+RTCD_EXTERN void (*vp9_fdct8x8_quant)(const int16_t* input,
+                                      int stride,
+                                      tran_low_t* coeff_ptr,
+                                      intptr_t n_coeffs,
+                                      int skip_block,
+                                      const int16_t* round_ptr,
+                                      const int16_t* quant_ptr,
+                                      tran_low_t* qcoeff_ptr,
+                                      tran_low_t* dqcoeff_ptr,
+                                      const int16_t* dequant_ptr,
+                                      uint16_t* eob_ptr,
+                                      const int16_t* scan,
+                                      const int16_t* iscan);
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht16x16_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
+void vp9_fht16x16_sse2(const int16_t* input,
+                       tran_low_t* output,
+                       int stride,
+                       int tx_type);
 #define vp9_fht16x16 vp9_fht16x16_sse2
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht4x4_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
+void vp9_fht4x4_sse2(const int16_t* input,
+                     tran_low_t* output,
+                     int stride,
+                     int tx_type);
 #define vp9_fht4x4 vp9_fht4x4_sse2
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht8x8_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
+void vp9_fht8x8_sse2(const int16_t* input,
+                     tran_low_t* output,
+                     int stride,
+                     int tx_type);
 #define vp9_fht8x8 vp9_fht8x8_sse2
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-void vp9_filter_by_weight16x16_sse2(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
+void vp9_filter_by_weight16x16_sse2(const uint8_t* src,
+                                    int src_stride,
+                                    uint8_t* dst,
+                                    int dst_stride,
+                                    int src_weight);
 #define vp9_filter_by_weight16x16 vp9_filter_by_weight16x16_sse2
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-void vp9_filter_by_weight8x8_sse2(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
+void vp9_filter_by_weight8x8_sse2(const uint8_t* src,
+                                  int src_stride,
+                                  uint8_t* dst,
+                                  int dst_stride,
+                                  int src_weight);
 #define vp9_filter_by_weight8x8 vp9_filter_by_weight8x8_sse2
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vp9_fwht4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vp9_fwht4x4_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_fwht4x4 vp9_fwht4x4_sse2
 
-int64_t vp9_highbd_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
-int64_t vp9_highbd_block_error_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
+int64_t vp9_highbd_block_error_c(const tran_low_t* coeff,
+                                 const tran_low_t* dqcoeff,
+                                 intptr_t block_size,
+                                 int64_t* ssz,
+                                 int bd);
+int64_t vp9_highbd_block_error_sse2(const tran_low_t* coeff,
+                                    const tran_low_t* dqcoeff,
+                                    intptr_t block_size,
+                                    int64_t* ssz,
+                                    int bd);
 #define vp9_highbd_block_error vp9_highbd_block_error_sse2
 
-void vp9_highbd_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht16x16_c(const int16_t* input,
+                           tran_low_t* output,
+                           int stride,
+                           int tx_type);
 #define vp9_highbd_fht16x16 vp9_highbd_fht16x16_c
 
-void vp9_highbd_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht4x4_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht4x4 vp9_highbd_fht4x4_c
 
-void vp9_highbd_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht8x8_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht8x8 vp9_highbd_fht8x8_c
 
-void vp9_highbd_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_highbd_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_highbd_fwht4x4 vp9_highbd_fwht4x4_c
 
-void vp9_highbd_iht16x16_256_add_c(const tran_low_t *input, uint16_t *output, int pitch, int tx_type, int bd);
+void vp9_highbd_iht16x16_256_add_c(const tran_low_t* input,
+                                   uint16_t* output,
+                                   int pitch,
+                                   int tx_type,
+                                   int bd);
 #define vp9_highbd_iht16x16_256_add vp9_highbd_iht16x16_256_add_c
 
-void vp9_highbd_iht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht4x4_16_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht4x4_16_add vp9_highbd_iht4x4_16_add_c
 
-void vp9_highbd_iht8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht8x8_64_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht8x8_64_add vp9_highbd_iht8x8_64_add_c
 
-void vp9_highbd_mbpost_proc_across_ip_c(uint16_t *src, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_across_ip_c(uint16_t* src,
+                                        int pitch,
+                                        int rows,
+                                        int cols,
+                                        int flimit);
 #define vp9_highbd_mbpost_proc_across_ip vp9_highbd_mbpost_proc_across_ip_c
 
-void vp9_highbd_mbpost_proc_down_c(uint16_t *dst, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_down_c(uint16_t* dst,
+                                   int pitch,
+                                   int rows,
+                                   int cols,
+                                   int flimit);
 #define vp9_highbd_mbpost_proc_down vp9_highbd_mbpost_proc_down_c
 
-void vp9_highbd_post_proc_down_and_across_c(const uint16_t *src_ptr, uint16_t *dst_ptr, int src_pixels_per_line, int dst_pixels_per_line, int rows, int cols, int flimit);
-#define vp9_highbd_post_proc_down_and_across vp9_highbd_post_proc_down_and_across_c
+void vp9_highbd_post_proc_down_and_across_c(const uint16_t* src_ptr,
+                                            uint16_t* dst_ptr,
+                                            int src_pixels_per_line,
+                                            int dst_pixels_per_line,
+                                            int rows,
+                                            int cols,
+                                            int flimit);
+#define vp9_highbd_post_proc_down_and_across \
+  vp9_highbd_post_proc_down_and_across_c
 
-void vp9_highbd_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_c(const tran_low_t* coeff_ptr,
+                              intptr_t n_coeffs,
+                              int skip_block,
+                              const int16_t* round_ptr,
+                              const int16_t* quant_ptr,
+                              tran_low_t* qcoeff_ptr,
+                              tran_low_t* dqcoeff_ptr,
+                              const int16_t* dequant_ptr,
+                              uint16_t* eob_ptr,
+                              const int16_t* scan,
+                              const int16_t* iscan);
 #define vp9_highbd_quantize_fp vp9_highbd_quantize_fp_c
 
-void vp9_highbd_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 #define vp9_highbd_quantize_fp_32x32 vp9_highbd_quantize_fp_32x32_c
 
-void vp9_highbd_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_highbd_temporal_filter_apply_c(const uint8_t* frame1,
+                                        unsigned int stride,
+                                        const uint8_t* frame2,
+                                        unsigned int block_width,
+                                        unsigned int block_height,
+                                        int strength,
+                                        int filter_weight,
+                                        uint32_t* accumulator,
+                                        uint16_t* count);
 #define vp9_highbd_temporal_filter_apply vp9_highbd_temporal_filter_apply_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
-void vp9_iht16x16_256_add_sse2(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
+void vp9_iht16x16_256_add_sse2(const tran_low_t* input,
+                               uint8_t* output,
+                               int pitch,
+                               int tx_type);
 #define vp9_iht16x16_256_add vp9_iht16x16_256_add_sse2
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht4x4_16_add_sse2(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
 #define vp9_iht4x4_16_add vp9_iht4x4_16_add_sse2
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht8x8_64_add_sse2(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht8x8_64_add_sse2(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
 #define vp9_iht8x8_64_add vp9_iht8x8_64_add_sse2
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_ssse3(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_quantize_fp)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
+void vp9_quantize_fp_sse2(const tran_low_t* coeff_ptr,
+                          intptr_t n_coeffs,
+                          int skip_block,
+                          const int16_t* round_ptr,
+                          const int16_t* quant_ptr,
+                          tran_low_t* qcoeff_ptr,
+                          tran_low_t* dqcoeff_ptr,
+                          const int16_t* dequant_ptr,
+                          uint16_t* eob_ptr,
+                          const int16_t* scan,
+                          const int16_t* iscan);
+void vp9_quantize_fp_ssse3(const tran_low_t* coeff_ptr,
+                           intptr_t n_coeffs,
+                           int skip_block,
+                           const int16_t* round_ptr,
+                           const int16_t* quant_ptr,
+                           tran_low_t* qcoeff_ptr,
+                           tran_low_t* dqcoeff_ptr,
+                           const int16_t* dequant_ptr,
+                           uint16_t* eob_ptr,
+                           const int16_t* scan,
+                           const int16_t* iscan);
+RTCD_EXTERN void (*vp9_quantize_fp)(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_32x32_ssse3(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_quantize_fp_32x32)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+void vp9_quantize_fp_32x32_ssse3(const tran_low_t* coeff_ptr,
+                                 intptr_t n_coeffs,
+                                 int skip_block,
+                                 const int16_t* round_ptr,
+                                 const int16_t* quant_ptr,
+                                 tran_low_t* qcoeff_ptr,
+                                 tran_low_t* dqcoeff_ptr,
+                                 const int16_t* dequant_ptr,
+                                 uint16_t* eob_ptr,
+                                 const int16_t* scan,
+                                 const int16_t* iscan);
+RTCD_EXTERN void (*vp9_quantize_fp_32x32)(const tran_low_t* coeff_ptr,
+                                          intptr_t n_coeffs,
+                                          int skip_block,
+                                          const int16_t* round_ptr,
+                                          const int16_t* quant_ptr,
+                                          tran_low_t* qcoeff_ptr,
+                                          tran_low_t* dqcoeff_ptr,
+                                          const int16_t* dequant_ptr,
+                                          uint16_t* eob_ptr,
+                                          const int16_t* scan,
+                                          const int16_t* iscan);
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
-void vp9_scale_and_extend_frame_ssse3(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
-RTCD_EXTERN void (*vp9_scale_and_extend_frame)(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
+void vp9_scale_and_extend_frame_ssse3(const struct yv12_buffer_config* src,
+                                      struct yv12_buffer_config* dst,
+                                      INTERP_FILTER filter_type,
+                                      int phase_scaler);
+RTCD_EXTERN void (*vp9_scale_and_extend_frame)(
+    const struct yv12_buffer_config* src,
+    struct yv12_buffer_config* dst,
+    INTERP_FILTER filter_type,
+    int phase_scaler);
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
-void vp9_temporal_filter_apply_sse4_1(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
-RTCD_EXTERN void (*vp9_temporal_filter_apply)(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
+void vp9_temporal_filter_apply_sse4_1(const uint8_t* frame1,
+                                      unsigned int stride,
+                                      const uint8_t* frame2,
+                                      unsigned int block_width,
+                                      unsigned int block_height,
+                                      int strength,
+                                      int filter_weight,
+                                      uint32_t* accumulator,
+                                      uint16_t* count);
+RTCD_EXTERN void (*vp9_temporal_filter_apply)(const uint8_t* frame1,
+                                              unsigned int stride,
+                                              const uint8_t* frame2,
+                                              unsigned int block_width,
+                                              unsigned int block_height,
+                                              int strength,
+                                              int filter_weight,
+                                              uint32_t* accumulator,
+                                              uint16_t* count);
 
 void vp9_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vp9_block_error = vp9_block_error_sse2;
-    if (flags & HAS_AVX2) vp9_block_error = vp9_block_error_avx2;
-    vp9_diamond_search_sad = vp9_diamond_search_sad_c;
-    if (flags & HAS_AVX) vp9_diamond_search_sad = vp9_diamond_search_sad_avx;
-    vp9_fdct8x8_quant = vp9_fdct8x8_quant_c;
-    if (flags & HAS_SSSE3) vp9_fdct8x8_quant = vp9_fdct8x8_quant_ssse3;
-    vp9_quantize_fp = vp9_quantize_fp_sse2;
-    if (flags & HAS_SSSE3) vp9_quantize_fp = vp9_quantize_fp_ssse3;
-    vp9_quantize_fp_32x32 = vp9_quantize_fp_32x32_c;
-    if (flags & HAS_SSSE3) vp9_quantize_fp_32x32 = vp9_quantize_fp_32x32_ssse3;
-    vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_c;
-    if (flags & HAS_SSSE3) vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_ssse3;
-    vp9_temporal_filter_apply = vp9_temporal_filter_apply_c;
-    if (flags & HAS_SSE4_1) vp9_temporal_filter_apply = vp9_temporal_filter_apply_sse4_1;
+  vp9_block_error = vp9_block_error_sse2;
+  if (flags & HAS_AVX2)
+    vp9_block_error = vp9_block_error_avx2;
+  vp9_diamond_search_sad = vp9_diamond_search_sad_c;
+  if (flags & HAS_AVX)
+    vp9_diamond_search_sad = vp9_diamond_search_sad_avx;
+  vp9_fdct8x8_quant = vp9_fdct8x8_quant_c;
+  if (flags & HAS_SSSE3)
+    vp9_fdct8x8_quant = vp9_fdct8x8_quant_ssse3;
+  vp9_quantize_fp = vp9_quantize_fp_sse2;
+  if (flags & HAS_SSSE3)
+    vp9_quantize_fp = vp9_quantize_fp_ssse3;
+  vp9_quantize_fp_32x32 = vp9_quantize_fp_32x32_c;
+  if (flags & HAS_SSSE3)
+    vp9_quantize_fp_32x32 = vp9_quantize_fp_32x32_ssse3;
+  vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_c;
+  if (flags & HAS_SSSE3)
+    vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_ssse3;
+  vp9_temporal_filter_apply = vp9_temporal_filter_apply_c;
+  if (flags & HAS_SSE4_1)
+    vp9_temporal_filter_apply = vp9_temporal_filter_apply_sse4_1;
 }
 #endif
 

third_party/libvpx/source/config/mac/x64/vpx_config.asm

diff --git a/third_party/libvpx/source/config/mac/x64/vpx_config.asm b/third_party/libvpx/source/config/mac/x64/vpx_config.asm
index d780d20..514d721 100644
--- a/third_party/libvpx/source/config/mac/x64/vpx_config.asm
+++ b/third_party/libvpx/source/config/mac/x64/vpx_config.asm
@@ -18,6 +18,7 @@
 %define HAVE_AVX 1
 %define HAVE_AVX2 1
 %define HAVE_VSX 0
+%define HAVE_MMI 0
 %define HAVE_VPX_PORTS 1
 %define HAVE_PTHREAD_H 1
 %define HAVE_UNISTD_H 0

third_party/libvpx/source/config/mac/x64/vpx_config.h

diff --git a/third_party/libvpx/source/config/mac/x64/vpx_config.h b/third_party/libvpx/source/config/mac/x64/vpx_config.h
index f946228..aae61b5c 100644
--- a/third_party/libvpx/source/config/mac/x64/vpx_config.h
+++ b/third_party/libvpx/source/config/mac/x64/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 1
 #define HAVE_AVX2 1
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/mac/x64/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/mac/x64/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/mac/x64/vpx_dsp_rtcd.h
index 742dbff..05579e2d 100644
--- a/third_party/libvpx/source/config/mac/x64/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/mac/x64/vpx_dsp_rtcd.h
@@ -14,2175 +14,7391 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
-unsigned int vpx_avg_4x4_sse2(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
+unsigned int vpx_avg_4x4_sse2(const uint8_t*, int p);
 #define vpx_avg_4x4 vpx_avg_4x4_sse2
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
-unsigned int vpx_avg_8x8_sse2(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
+unsigned int vpx_avg_8x8_sse2(const uint8_t*, int p);
 #define vpx_avg_8x8 vpx_avg_8x8_sse2
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-void vpx_comp_avg_pred_sse2(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
+void vpx_comp_avg_pred_sse2(uint8_t* comp_pred,
+                            const uint8_t* pred,
+                            int width,
+                            int height,
+                            const uint8_t* ref,
+                            int ref_stride);
 #define vpx_comp_avg_pred vpx_comp_avg_pred_sse2
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_convolve8_sse2(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve8_ssse3(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avx2(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+RTCD_EXTERN void (*vpx_convolve8)(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avg_sse2(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
+void vpx_convolve8_avg_ssse3(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+RTCD_EXTERN void (*vpx_convolve8_avg)(const uint8_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h);
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg_horiz)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_avg_horiz_sse2(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
+void vpx_convolve8_avg_horiz_ssse3(const uint8_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h);
+RTCD_EXTERN void (*vpx_convolve8_avg_horiz)(const uint8_t* src,
+                                            ptrdiff_t src_stride,
+                                            uint8_t* dst,
+                                            ptrdiff_t dst_stride,
+                                            const int16_t* filter_x,
+                                            int x_step_q4,
+                                            const int16_t* filter_y,
+                                            int y_step_q4,
+                                            int w,
+                                            int h);
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg_vert)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_avg_vert_sse2(const uint8_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h);
+void vpx_convolve8_avg_vert_ssse3(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
+RTCD_EXTERN void (*vpx_convolve8_avg_vert)(const uint8_t* src,
+                                           ptrdiff_t src_stride,
+                                           uint8_t* dst,
+                                           ptrdiff_t dst_stride,
+                                           const int16_t* filter_x,
+                                           int x_step_q4,
+                                           const int16_t* filter_y,
+                                           int y_step_q4,
+                                           int w,
+                                           int h);
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_horiz)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+void vpx_convolve8_horiz_sse2(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_horiz_ssse3(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_horiz_avx2(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+RTCD_EXTERN void (*vpx_convolve8_horiz)(const uint8_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint8_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h);
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_vert)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
+void vpx_convolve8_vert_sse2(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+void vpx_convolve8_vert_ssse3(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_vert_avx2(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+RTCD_EXTERN void (*vpx_convolve8_vert)(const uint8_t* src,
+                                       ptrdiff_t src_stride,
+                                       uint8_t* dst,
+                                       ptrdiff_t dst_stride,
+                                       const int16_t* filter_x,
+                                       int x_step_q4,
+                                       const int16_t* filter_y,
+                                       int y_step_q4,
+                                       int w,
+                                       int h);
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_avg_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve_avg_sse2(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_convolve_avg vpx_convolve_avg_sse2
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_copy_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve_copy_sse2(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_convolve_copy vpx_convolve_copy_sse2
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_c
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_c
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_c
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_c
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d153_predictor_16x16_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_16x16)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d153_predictor_32x32_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_32x32)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_4x4_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d153_predictor_4x4_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_4x4)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d153_predictor_8x8_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_8x8)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d207_predictor_16x16_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_16x16)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d207_predictor_32x32_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_32x32)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d207_predictor_4x4_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_d207_predictor_4x4 vpx_d207_predictor_4x4_sse2
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d207_predictor_8x8_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_8x8)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_16x16_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_16x16)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_32x32_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_32x32)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_4x4_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d45_predictor_4x4 vpx_d45_predictor_4x4_sse2
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_8x8_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d45_predictor_8x8 vpx_d45_predictor_8x8_sse2
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d63_predictor_16x16_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_16x16)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d63_predictor_32x32_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_32x32)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_4x4_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d63_predictor_4x4_ssse3(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_4x4)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d63_predictor_8x8_ssse3(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_8x8)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_16x16_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_128_predictor_16x16 vpx_dc_128_predictor_16x16_sse2
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_32x32_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_128_predictor_32x32 vpx_dc_128_predictor_32x32_sse2
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_4x4_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_128_predictor_4x4 vpx_dc_128_predictor_4x4_sse2
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_8x8_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_128_predictor_8x8 vpx_dc_128_predictor_8x8_sse2
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_16x16_sse2(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
 #define vpx_dc_left_predictor_16x16 vpx_dc_left_predictor_16x16_sse2
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_32x32_sse2(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
 #define vpx_dc_left_predictor_32x32 vpx_dc_left_predictor_32x32_sse2
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_4x4_sse2(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
 #define vpx_dc_left_predictor_4x4 vpx_dc_left_predictor_4x4_sse2
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_8x8_sse2(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
 #define vpx_dc_left_predictor_8x8 vpx_dc_left_predictor_8x8_sse2
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_16x16_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_predictor_16x16 vpx_dc_predictor_16x16_sse2
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_32x32_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_predictor_32x32 vpx_dc_predictor_32x32_sse2
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_4x4_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_dc_predictor_4x4 vpx_dc_predictor_4x4_sse2
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_8x8_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_dc_predictor_8x8 vpx_dc_predictor_8x8_sse2
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_16x16_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_top_predictor_16x16 vpx_dc_top_predictor_16x16_sse2
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_32x32_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_top_predictor_32x32 vpx_dc_top_predictor_32x32_sse2
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_4x4_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_top_predictor_4x4 vpx_dc_top_predictor_4x4_sse2
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_8x8_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_top_predictor_8x8 vpx_dc_top_predictor_8x8_sse2
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16 vpx_fdct16x16_sse2
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_1_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_1_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16_1 vpx_fdct16x16_1_sse2
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32 vpx_fdct32x32_sse2
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_1_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_1_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_1 vpx_fdct32x32_1_sse2
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_rd_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_rd_sse2(const int16_t* input,
+                           tran_low_t* output,
+                           int stride);
 #define vpx_fdct32x32_rd vpx_fdct32x32_rd_sse2
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4 vpx_fdct4x4_sse2
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_1_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_1_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4_1 vpx_fdct4x4_1_sse2
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8 vpx_fdct8x8_sse2
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_1_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_1_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8_1 vpx_fdct8x8_1_sse2
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-RTCD_EXTERN void (*vpx_get16x16var)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
+void vpx_get16x16var_sse2(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
+void vpx_get16x16var_avx2(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
+RTCD_EXTERN void (*vpx_get16x16var)(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse,
+                                    int* sum);
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_c
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get8x8var_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
+void vpx_get8x8var_sse2(const uint8_t* src_ptr,
+                        int source_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        unsigned int* sse,
+                        int* sum);
 #define vpx_get8x8var vpx_get8x8var_sse2
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
-unsigned int vpx_get_mb_ss_sse2(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
+unsigned int vpx_get_mb_ss_sse2(const int16_t*);
 #define vpx_get_mb_ss vpx_get_mb_ss_sse2
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_16x16_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_h_predictor_16x16 vpx_h_predictor_16x16_sse2
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_32x32_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_h_predictor_32x32 vpx_h_predictor_32x32_sse2
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_4x4_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_h_predictor_4x4 vpx_h_predictor_4x4_sse2
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_8x8_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_h_predictor_8x8 vpx_h_predictor_8x8_sse2
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_16x16_sse2(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          tran_low_t* coeff);
+void vpx_hadamard_16x16_sse2(const int16_t* src_diff,
+                             int src_stride,
+                             tran_low_t* coeff);
 #define vpx_hadamard_16x16 vpx_hadamard_16x16_sse2
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_8x8_sse2(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_8x8_ssse3(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-RTCD_EXTERN void (*vpx_hadamard_8x8)(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        tran_low_t* coeff);
+void vpx_hadamard_8x8_sse2(const int16_t* src_diff,
+                           int src_stride,
+                           tran_low_t* coeff);
+void vpx_hadamard_8x8_ssse3(const int16_t* src_diff,
+                            int src_stride,
+                            tran_low_t* coeff);
+RTCD_EXTERN void (*vpx_hadamard_8x8)(const int16_t* src_diff,
+                                     int src_stride,
+                                     tran_low_t* coeff);
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_highbd_10_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_10_get16x16var vpx_highbd_10_get16x16var_c
 
-void vpx_highbd_10_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_10_get8x8var vpx_highbd_10_get8x8var_c
 
-unsigned int vpx_highbd_10_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+unsigned int vpx_highbd_10_mse16x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_mse16x16 vpx_highbd_10_mse16x16_sse2
 
-unsigned int vpx_highbd_10_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse16x8 vpx_highbd_10_mse16x8_c
 
-unsigned int vpx_highbd_10_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse8x16 vpx_highbd_10_mse8x16_c
 
-unsigned int vpx_highbd_10_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
+unsigned int vpx_highbd_10_mse8x8_sse2(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
 #define vpx_highbd_10_mse8x8 vpx_highbd_10_mse8x8_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x16 vpx_highbd_10_sub_pixel_avg_variance16x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x16 \
+  vpx_highbd_10_sub_pixel_avg_variance16x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x32 vpx_highbd_10_sub_pixel_avg_variance16x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x32 \
+  vpx_highbd_10_sub_pixel_avg_variance16x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x8 vpx_highbd_10_sub_pixel_avg_variance16x8_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x8 \
+  vpx_highbd_10_sub_pixel_avg_variance16x8_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x16 vpx_highbd_10_sub_pixel_avg_variance32x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x16 \
+  vpx_highbd_10_sub_pixel_avg_variance32x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x32 vpx_highbd_10_sub_pixel_avg_variance32x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x32 \
+  vpx_highbd_10_sub_pixel_avg_variance32x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x64 vpx_highbd_10_sub_pixel_avg_variance32x64_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x64 \
+  vpx_highbd_10_sub_pixel_avg_variance32x64_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x4 vpx_highbd_10_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x4 \
+  vpx_highbd_10_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x8 vpx_highbd_10_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x8 \
+  vpx_highbd_10_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance64x32 vpx_highbd_10_sub_pixel_avg_variance64x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance64x32 \
+  vpx_highbd_10_sub_pixel_avg_variance64x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance64x64 vpx_highbd_10_sub_pixel_avg_variance64x64_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance64x64 \
+  vpx_highbd_10_sub_pixel_avg_variance64x64_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x16 vpx_highbd_10_sub_pixel_avg_variance8x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x16 \
+  vpx_highbd_10_sub_pixel_avg_variance8x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x4 vpx_highbd_10_sub_pixel_avg_variance8x4_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x4 \
+  vpx_highbd_10_sub_pixel_avg_variance8x4_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x8 vpx_highbd_10_sub_pixel_avg_variance8x8_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x8 \
+  vpx_highbd_10_sub_pixel_avg_variance8x8_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x16 vpx_highbd_10_sub_pixel_variance16x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x16 \
+  vpx_highbd_10_sub_pixel_variance16x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x32 vpx_highbd_10_sub_pixel_variance16x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x32 \
+  vpx_highbd_10_sub_pixel_variance16x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x8 vpx_highbd_10_sub_pixel_variance16x8_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x8 \
+  vpx_highbd_10_sub_pixel_variance16x8_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x16 vpx_highbd_10_sub_pixel_variance32x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x16 \
+  vpx_highbd_10_sub_pixel_variance32x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x32 vpx_highbd_10_sub_pixel_variance32x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x32 \
+  vpx_highbd_10_sub_pixel_variance32x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x64 vpx_highbd_10_sub_pixel_variance32x64_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x64 \
+  vpx_highbd_10_sub_pixel_variance32x64_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x4 vpx_highbd_10_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x4 \
+  vpx_highbd_10_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x8 vpx_highbd_10_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x8 \
+  vpx_highbd_10_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance64x32 vpx_highbd_10_sub_pixel_variance64x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance64x32 \
+  vpx_highbd_10_sub_pixel_variance64x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance64x64 vpx_highbd_10_sub_pixel_variance64x64_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance64x64 \
+  vpx_highbd_10_sub_pixel_variance64x64_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x16 vpx_highbd_10_sub_pixel_variance8x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x16 \
+  vpx_highbd_10_sub_pixel_variance8x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x4 vpx_highbd_10_sub_pixel_variance8x4_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x4 \
+  vpx_highbd_10_sub_pixel_variance8x4_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x8 vpx_highbd_10_sub_pixel_variance8x8_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x8 \
+  vpx_highbd_10_sub_pixel_variance8x8_sse2
 
-unsigned int vpx_highbd_10_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance16x16 vpx_highbd_10_variance16x16_sse2
 
-unsigned int vpx_highbd_10_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance16x32 vpx_highbd_10_variance16x32_sse2
 
-unsigned int vpx_highbd_10_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_10_variance16x8 vpx_highbd_10_variance16x8_sse2
 
-unsigned int vpx_highbd_10_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance32x16 vpx_highbd_10_variance32x16_sse2
 
-unsigned int vpx_highbd_10_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance32x32 vpx_highbd_10_variance32x32_sse2
 
-unsigned int vpx_highbd_10_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance32x64 vpx_highbd_10_variance32x64_sse2
 
-unsigned int vpx_highbd_10_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x4 vpx_highbd_10_variance4x4_c
 
-unsigned int vpx_highbd_10_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x8 vpx_highbd_10_variance4x8_c
 
-unsigned int vpx_highbd_10_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance64x32 vpx_highbd_10_variance64x32_sse2
 
-unsigned int vpx_highbd_10_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance64x64 vpx_highbd_10_variance64x64_sse2
 
-unsigned int vpx_highbd_10_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_10_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_10_variance8x16 vpx_highbd_10_variance8x16_sse2
 
-unsigned int vpx_highbd_10_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance8x4 vpx_highbd_10_variance8x4_c
 
-unsigned int vpx_highbd_10_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_10_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 #define vpx_highbd_10_variance8x8 vpx_highbd_10_variance8x8_sse2
 
-void vpx_highbd_12_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_12_get16x16var vpx_highbd_12_get16x16var_c
 
-void vpx_highbd_12_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_12_get8x8var vpx_highbd_12_get8x8var_c
 
-unsigned int vpx_highbd_12_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+unsigned int vpx_highbd_12_mse16x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_mse16x16 vpx_highbd_12_mse16x16_sse2
 
-unsigned int vpx_highbd_12_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse16x8 vpx_highbd_12_mse16x8_c
 
-unsigned int vpx_highbd_12_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse8x16 vpx_highbd_12_mse8x16_c
 
-unsigned int vpx_highbd_12_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
+unsigned int vpx_highbd_12_mse8x8_sse2(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
 #define vpx_highbd_12_mse8x8 vpx_highbd_12_mse8x8_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x16 vpx_highbd_12_sub_pixel_avg_variance16x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x16 \
+  vpx_highbd_12_sub_pixel_avg_variance16x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x32 vpx_highbd_12_sub_pixel_avg_variance16x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x32 \
+  vpx_highbd_12_sub_pixel_avg_variance16x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x8 vpx_highbd_12_sub_pixel_avg_variance16x8_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x8 \
+  vpx_highbd_12_sub_pixel_avg_variance16x8_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x16 vpx_highbd_12_sub_pixel_avg_variance32x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x16 \
+  vpx_highbd_12_sub_pixel_avg_variance32x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x32 vpx_highbd_12_sub_pixel_avg_variance32x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x32 \
+  vpx_highbd_12_sub_pixel_avg_variance32x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x64 vpx_highbd_12_sub_pixel_avg_variance32x64_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x64 \
+  vpx_highbd_12_sub_pixel_avg_variance32x64_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x4 vpx_highbd_12_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x4 \
+  vpx_highbd_12_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x8 vpx_highbd_12_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x8 \
+  vpx_highbd_12_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance64x32 vpx_highbd_12_sub_pixel_avg_variance64x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance64x32 \
+  vpx_highbd_12_sub_pixel_avg_variance64x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance64x64 vpx_highbd_12_sub_pixel_avg_variance64x64_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance64x64 \
+  vpx_highbd_12_sub_pixel_avg_variance64x64_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x16 vpx_highbd_12_sub_pixel_avg_variance8x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x16 \
+  vpx_highbd_12_sub_pixel_avg_variance8x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x4 vpx_highbd_12_sub_pixel_avg_variance8x4_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x4 \
+  vpx_highbd_12_sub_pixel_avg_variance8x4_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x8 vpx_highbd_12_sub_pixel_avg_variance8x8_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x8 \
+  vpx_highbd_12_sub_pixel_avg_variance8x8_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x16 vpx_highbd_12_sub_pixel_variance16x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x16 \
+  vpx_highbd_12_sub_pixel_variance16x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x32 vpx_highbd_12_sub_pixel_variance16x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x32 \
+  vpx_highbd_12_sub_pixel_variance16x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x8 vpx_highbd_12_sub_pixel_variance16x8_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x8 \
+  vpx_highbd_12_sub_pixel_variance16x8_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x16 vpx_highbd_12_sub_pixel_variance32x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x16 \
+  vpx_highbd_12_sub_pixel_variance32x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x32 vpx_highbd_12_sub_pixel_variance32x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x32 \
+  vpx_highbd_12_sub_pixel_variance32x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x64 vpx_highbd_12_sub_pixel_variance32x64_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x64 \
+  vpx_highbd_12_sub_pixel_variance32x64_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x4 vpx_highbd_12_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x4 \
+  vpx_highbd_12_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x8 vpx_highbd_12_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x8 \
+  vpx_highbd_12_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance64x32 vpx_highbd_12_sub_pixel_variance64x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance64x32 \
+  vpx_highbd_12_sub_pixel_variance64x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance64x64 vpx_highbd_12_sub_pixel_variance64x64_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance64x64 \
+  vpx_highbd_12_sub_pixel_variance64x64_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x16 vpx_highbd_12_sub_pixel_variance8x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x16 \
+  vpx_highbd_12_sub_pixel_variance8x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x4 vpx_highbd_12_sub_pixel_variance8x4_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x4 \
+  vpx_highbd_12_sub_pixel_variance8x4_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x8 vpx_highbd_12_sub_pixel_variance8x8_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x8 \
+  vpx_highbd_12_sub_pixel_variance8x8_sse2
 
-unsigned int vpx_highbd_12_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance16x16 vpx_highbd_12_variance16x16_sse2
 
-unsigned int vpx_highbd_12_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance16x32 vpx_highbd_12_variance16x32_sse2
 
-unsigned int vpx_highbd_12_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_12_variance16x8 vpx_highbd_12_variance16x8_sse2
 
-unsigned int vpx_highbd_12_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance32x16 vpx_highbd_12_variance32x16_sse2
 
-unsigned int vpx_highbd_12_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance32x32 vpx_highbd_12_variance32x32_sse2
 
-unsigned int vpx_highbd_12_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance32x64 vpx_highbd_12_variance32x64_sse2
 
-unsigned int vpx_highbd_12_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x4 vpx_highbd_12_variance4x4_c
 
-unsigned int vpx_highbd_12_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x8 vpx_highbd_12_variance4x8_c
 
-unsigned int vpx_highbd_12_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance64x32 vpx_highbd_12_variance64x32_sse2
 
-unsigned int vpx_highbd_12_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance64x64 vpx_highbd_12_variance64x64_sse2
 
-unsigned int vpx_highbd_12_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_12_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_12_variance8x16 vpx_highbd_12_variance8x16_sse2
 
-unsigned int vpx_highbd_12_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance8x4 vpx_highbd_12_variance8x4_c
 
-unsigned int vpx_highbd_12_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_12_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 #define vpx_highbd_12_variance8x8 vpx_highbd_12_variance8x8_sse2
 
-void vpx_highbd_8_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get16x16var_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse,
+                                int* sum);
 #define vpx_highbd_8_get16x16var vpx_highbd_8_get16x16var_c
 
-void vpx_highbd_8_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get8x8var_c(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              unsigned int* sse,
+                              int* sum);
 #define vpx_highbd_8_get8x8var vpx_highbd_8_get8x8var_c
 
-unsigned int vpx_highbd_8_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
+unsigned int vpx_highbd_8_mse16x16_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int recon_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_mse16x16 vpx_highbd_8_mse16x16_sse2
 
-unsigned int vpx_highbd_8_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse16x8 vpx_highbd_8_mse16x8_c
 
-unsigned int vpx_highbd_8_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x16_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse8x16 vpx_highbd_8_mse8x16_c
 
-unsigned int vpx_highbd_8_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x8_c(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int recon_stride,
+                                   unsigned int* sse);
+unsigned int vpx_highbd_8_mse8x8_sse2(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
 #define vpx_highbd_8_mse8x8 vpx_highbd_8_mse8x8_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x16 vpx_highbd_8_sub_pixel_avg_variance16x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x16 \
+  vpx_highbd_8_sub_pixel_avg_variance16x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x32 vpx_highbd_8_sub_pixel_avg_variance16x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x32 \
+  vpx_highbd_8_sub_pixel_avg_variance16x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x8 vpx_highbd_8_sub_pixel_avg_variance16x8_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x8 \
+  vpx_highbd_8_sub_pixel_avg_variance16x8_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x16 vpx_highbd_8_sub_pixel_avg_variance32x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x16 \
+  vpx_highbd_8_sub_pixel_avg_variance32x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x32 vpx_highbd_8_sub_pixel_avg_variance32x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x32 \
+  vpx_highbd_8_sub_pixel_avg_variance32x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x64 vpx_highbd_8_sub_pixel_avg_variance32x64_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x64 \
+  vpx_highbd_8_sub_pixel_avg_variance32x64_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x4 vpx_highbd_8_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x4 \
+  vpx_highbd_8_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x8 vpx_highbd_8_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x8 \
+  vpx_highbd_8_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance64x32 vpx_highbd_8_sub_pixel_avg_variance64x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance64x32 \
+  vpx_highbd_8_sub_pixel_avg_variance64x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance64x64 vpx_highbd_8_sub_pixel_avg_variance64x64_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance64x64 \
+  vpx_highbd_8_sub_pixel_avg_variance64x64_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x16 vpx_highbd_8_sub_pixel_avg_variance8x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x16 \
+  vpx_highbd_8_sub_pixel_avg_variance8x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x4 vpx_highbd_8_sub_pixel_avg_variance8x4_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x4 \
+  vpx_highbd_8_sub_pixel_avg_variance8x4_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x8 vpx_highbd_8_sub_pixel_avg_variance8x8_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x8 \
+  vpx_highbd_8_sub_pixel_avg_variance8x8_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x16 vpx_highbd_8_sub_pixel_variance16x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x16 \
+  vpx_highbd_8_sub_pixel_variance16x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x32 vpx_highbd_8_sub_pixel_variance16x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x32 \
+  vpx_highbd_8_sub_pixel_variance16x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x8 vpx_highbd_8_sub_pixel_variance16x8_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x8 \
+  vpx_highbd_8_sub_pixel_variance16x8_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x16 vpx_highbd_8_sub_pixel_variance32x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x16 \
+  vpx_highbd_8_sub_pixel_variance32x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x32 vpx_highbd_8_sub_pixel_variance32x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x32 \
+  vpx_highbd_8_sub_pixel_variance32x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x64 vpx_highbd_8_sub_pixel_variance32x64_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x64 \
+  vpx_highbd_8_sub_pixel_variance32x64_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x4 vpx_highbd_8_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x8 vpx_highbd_8_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance64x32 vpx_highbd_8_sub_pixel_variance64x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance64x32 \
+  vpx_highbd_8_sub_pixel_variance64x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance64x64 vpx_highbd_8_sub_pixel_variance64x64_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance64x64 \
+  vpx_highbd_8_sub_pixel_variance64x64_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance8x16 vpx_highbd_8_sub_pixel_variance8x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance8x16 \
+  vpx_highbd_8_sub_pixel_variance8x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance8x4 vpx_highbd_8_sub_pixel_variance8x4_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance8x4 \
+  vpx_highbd_8_sub_pixel_variance8x4_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance8x8 vpx_highbd_8_sub_pixel_variance8x8_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance8x8 \
+  vpx_highbd_8_sub_pixel_variance8x8_sse2
 
-unsigned int vpx_highbd_8_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance16x16 vpx_highbd_8_variance16x16_sse2
 
-unsigned int vpx_highbd_8_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance16x32 vpx_highbd_8_variance16x32_sse2
 
-unsigned int vpx_highbd_8_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 #define vpx_highbd_8_variance16x8 vpx_highbd_8_variance16x8_sse2
 
-unsigned int vpx_highbd_8_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance32x16 vpx_highbd_8_variance32x16_sse2
 
-unsigned int vpx_highbd_8_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance32x32 vpx_highbd_8_variance32x32_sse2
 
-unsigned int vpx_highbd_8_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x64_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance32x64 vpx_highbd_8_variance32x64_sse2
 
-unsigned int vpx_highbd_8_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x4 vpx_highbd_8_variance4x4_c
 
-unsigned int vpx_highbd_8_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x8 vpx_highbd_8_variance4x8_c
 
-unsigned int vpx_highbd_8_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance64x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance64x32 vpx_highbd_8_variance64x32_sse2
 
-unsigned int vpx_highbd_8_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance64x64_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance64x64 vpx_highbd_8_variance64x64_sse2
 
-unsigned int vpx_highbd_8_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x16_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_8_variance8x16_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 #define vpx_highbd_8_variance8x16 vpx_highbd_8_variance8x16_sse2
 
-unsigned int vpx_highbd_8_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance8x4 vpx_highbd_8_variance8x4_c
 
-unsigned int vpx_highbd_8_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
+unsigned int vpx_highbd_8_variance8x8_sse2(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_8_variance8x8 vpx_highbd_8_variance8x8_sse2
 
-unsigned int vpx_highbd_avg_4x4_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_4x4_c(const uint8_t*, int p);
 #define vpx_highbd_avg_4x4 vpx_highbd_avg_4x4_c
 
-unsigned int vpx_highbd_avg_8x8_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_8x8_c(const uint8_t*, int p);
 #define vpx_highbd_avg_8x8 vpx_highbd_avg_8x8_c
 
-void vpx_highbd_comp_avg_pred_c(uint16_t *comp_pred, const uint8_t *pred8, int width, int height, const uint8_t *ref8, int ref_stride);
+void vpx_highbd_comp_avg_pred_c(uint16_t* comp_pred,
+                                const uint8_t* pred8,
+                                int width,
+                                int height,
+                                const uint8_t* ref8,
+                                int ref_stride);
 #define vpx_highbd_comp_avg_pred vpx_highbd_comp_avg_pred_c
 
-void vpx_highbd_convolve8_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_c(const uint16_t* src,
+                            ptrdiff_t src_stride,
+                            uint16_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h,
+                            int bps);
+void vpx_highbd_convolve8_sse2(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+void vpx_highbd_convolve8_avx2(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8)(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
 
-void vpx_highbd_convolve8_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
+void vpx_highbd_convolve8_avg_sse2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+void vpx_highbd_convolve8_avg_avx2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg)(const uint16_t* src,
+                                             ptrdiff_t src_stride,
+                                             uint16_t* dst,
+                                             ptrdiff_t dst_stride,
+                                             const int16_t* filter_x,
+                                             int x_step_q4,
+                                             const int16_t* filter_y,
+                                             int y_step_q4,
+                                             int w,
+                                             int h,
+                                             int bps);
 
-void vpx_highbd_convolve8_avg_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_horiz_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_horiz_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg_horiz)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_horiz_c(const uint16_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint16_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h,
+                                      int bps);
+void vpx_highbd_convolve8_avg_horiz_sse2(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
+void vpx_highbd_convolve8_avg_horiz_avx2(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg_horiz)(const uint16_t* src,
+                                                   ptrdiff_t src_stride,
+                                                   uint16_t* dst,
+                                                   ptrdiff_t dst_stride,
+                                                   const int16_t* filter_x,
+                                                   int x_step_q4,
+                                                   const int16_t* filter_y,
+                                                   int y_step_q4,
+                                                   int w,
+                                                   int h,
+                                                   int bps);
 
-void vpx_highbd_convolve8_avg_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_vert_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_vert_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg_vert)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_vert_c(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+void vpx_highbd_convolve8_avg_vert_sse2(const uint16_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint16_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h,
+                                        int bps);
+void vpx_highbd_convolve8_avg_vert_avx2(const uint16_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint16_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h,
+                                        int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg_vert)(const uint16_t* src,
+                                                  ptrdiff_t src_stride,
+                                                  uint16_t* dst,
+                                                  ptrdiff_t dst_stride,
+                                                  const int16_t* filter_x,
+                                                  int x_step_q4,
+                                                  const int16_t* filter_y,
+                                                  int y_step_q4,
+                                                  int w,
+                                                  int h,
+                                                  int bps);
 
-void vpx_highbd_convolve8_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_horiz_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_horiz_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_horiz)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_horiz_c(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+void vpx_highbd_convolve8_horiz_sse2(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+void vpx_highbd_convolve8_horiz_avx2(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_horiz)(const uint16_t* src,
+                                               ptrdiff_t src_stride,
+                                               uint16_t* dst,
+                                               ptrdiff_t dst_stride,
+                                               const int16_t* filter_x,
+                                               int x_step_q4,
+                                               const int16_t* filter_y,
+                                               int y_step_q4,
+                                               int w,
+                                               int h,
+                                               int bps);
 
-void vpx_highbd_convolve8_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_vert_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_vert_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_vert)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_vert_c(const uint16_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint16_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h,
+                                 int bps);
+void vpx_highbd_convolve8_vert_sse2(const uint16_t* src,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst,
+                                    ptrdiff_t dst_stride,
+                                    const int16_t* filter_x,
+                                    int x_step_q4,
+                                    const int16_t* filter_y,
+                                    int y_step_q4,
+                                    int w,
+                                    int h,
+                                    int bps);
+void vpx_highbd_convolve8_vert_avx2(const uint16_t* src,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst,
+                                    ptrdiff_t dst_stride,
+                                    const int16_t* filter_x,
+                                    int x_step_q4,
+                                    const int16_t* filter_y,
+                                    int y_step_q4,
+                                    int w,
+                                    int h,
+                                    int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_vert)(const uint16_t* src,
+                                              ptrdiff_t src_stride,
+                                              uint16_t* dst,
+                                              ptrdiff_t dst_stride,
+                                              const int16_t* filter_x,
+                                              int x_step_q4,
+                                              const int16_t* filter_y,
+                                              int y_step_q4,
+                                              int w,
+                                              int h,
+                                              int bps);
 
-void vpx_highbd_convolve_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_avg_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_avg_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve_avg)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_avg_c(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+void vpx_highbd_convolve_avg_sse2(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+void vpx_highbd_convolve_avg_avx2(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve_avg)(const uint16_t* src,
+                                            ptrdiff_t src_stride,
+                                            uint16_t* dst,
+                                            ptrdiff_t dst_stride,
+                                            const int16_t* filter_x,
+                                            int x_step_q4,
+                                            const int16_t* filter_y,
+                                            int y_step_q4,
+                                            int w,
+                                            int h,
+                                            int bps);
 
-void vpx_highbd_convolve_copy_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_copy_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_copy_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve_copy)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_copy_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
+void vpx_highbd_convolve_copy_sse2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+void vpx_highbd_convolve_copy_avx2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve_copy)(const uint16_t* src,
+                                             ptrdiff_t src_stride,
+                                             uint16_t* dst,
+                                             ptrdiff_t dst_stride,
+                                             const int16_t* filter_x,
+                                             int x_step_q4,
+                                             const int16_t* filter_y,
+                                             int y_step_q4,
+                                             int w,
+                                             int h,
+                                             int bps);
 
-void vpx_highbd_d117_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_16x16 vpx_highbd_d117_predictor_16x16_c
 
-void vpx_highbd_d117_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_32x32 vpx_highbd_d117_predictor_32x32_c
 
-void vpx_highbd_d117_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_4x4 vpx_highbd_d117_predictor_4x4_c
 
-void vpx_highbd_d117_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_8x8 vpx_highbd_d117_predictor_8x8_c
 
-void vpx_highbd_d135_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_16x16 vpx_highbd_d135_predictor_16x16_c
 
-void vpx_highbd_d135_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_32x32 vpx_highbd_d135_predictor_32x32_c
 
-void vpx_highbd_d135_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_4x4 vpx_highbd_d135_predictor_4x4_c
 
-void vpx_highbd_d135_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_8x8 vpx_highbd_d135_predictor_8x8_c
 
-void vpx_highbd_d153_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_16x16 vpx_highbd_d153_predictor_16x16_c
 
-void vpx_highbd_d153_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_32x32 vpx_highbd_d153_predictor_32x32_c
 
-void vpx_highbd_d153_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_4x4 vpx_highbd_d153_predictor_4x4_c
 
-void vpx_highbd_d153_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_8x8 vpx_highbd_d153_predictor_8x8_c
 
-void vpx_highbd_d207_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_16x16 vpx_highbd_d207_predictor_16x16_c
 
-void vpx_highbd_d207_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_32x32 vpx_highbd_d207_predictor_32x32_c
 
-void vpx_highbd_d207_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_4x4 vpx_highbd_d207_predictor_4x4_c
 
-void vpx_highbd_d207_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_8x8 vpx_highbd_d207_predictor_8x8_c
 
-void vpx_highbd_d45_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_16x16 vpx_highbd_d45_predictor_16x16_c
 
-void vpx_highbd_d45_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_32x32 vpx_highbd_d45_predictor_32x32_c
 
-void vpx_highbd_d45_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_4x4 vpx_highbd_d45_predictor_4x4_c
 
-void vpx_highbd_d45_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_8x8 vpx_highbd_d45_predictor_8x8_c
 
-void vpx_highbd_d63_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_16x16 vpx_highbd_d63_predictor_16x16_c
 
-void vpx_highbd_d63_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_32x32 vpx_highbd_d63_predictor_32x32_c
 
-void vpx_highbd_d63_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_4x4 vpx_highbd_d63_predictor_4x4_c
 
-void vpx_highbd_d63_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_8x8 vpx_highbd_d63_predictor_8x8_c
 
-void vpx_highbd_dc_128_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_16x16 vpx_highbd_dc_128_predictor_16x16_c
 
-void vpx_highbd_dc_128_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_32x32 vpx_highbd_dc_128_predictor_32x32_c
 
-void vpx_highbd_dc_128_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_4x4 vpx_highbd_dc_128_predictor_4x4_c
 
-void vpx_highbd_dc_128_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_8x8 vpx_highbd_dc_128_predictor_8x8_c
 
-void vpx_highbd_dc_left_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_16x16_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_16x16 vpx_highbd_dc_left_predictor_16x16_c
 
-void vpx_highbd_dc_left_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_32x32_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_32x32 vpx_highbd_dc_left_predictor_32x32_c
 
-void vpx_highbd_dc_left_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_4x4_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_4x4 vpx_highbd_dc_left_predictor_4x4_c
 
-void vpx_highbd_dc_left_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_8x8_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_8x8 vpx_highbd_dc_left_predictor_8x8_c
 
-void vpx_highbd_dc_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_dc_predictor_16x16_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_predictor_16x16 vpx_highbd_dc_predictor_16x16_sse2
 
-void vpx_highbd_dc_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_dc_predictor_32x32_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_predictor_32x32 vpx_highbd_dc_predictor_32x32_sse2
 
-void vpx_highbd_dc_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_dc_predictor_4x4_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_dc_predictor_4x4 vpx_highbd_dc_predictor_4x4_sse2
 
-void vpx_highbd_dc_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_dc_predictor_8x8_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_dc_predictor_8x8 vpx_highbd_dc_predictor_8x8_sse2
 
-void vpx_highbd_dc_top_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_16x16 vpx_highbd_dc_top_predictor_16x16_c
 
-void vpx_highbd_dc_top_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_32x32 vpx_highbd_dc_top_predictor_32x32_c
 
-void vpx_highbd_dc_top_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_4x4 vpx_highbd_dc_top_predictor_4x4_c
 
-void vpx_highbd_dc_top_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_8x8 vpx_highbd_dc_top_predictor_8x8_c
 
-void vpx_highbd_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct16x16_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
+void vpx_highbd_fdct16x16_sse2(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
 #define vpx_highbd_fdct16x16 vpx_highbd_fdct16x16_sse2
 
-void vpx_highbd_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct16x16_1 vpx_highbd_fdct16x16_1_c
 
-void vpx_highbd_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct32x32_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
+void vpx_highbd_fdct32x32_sse2(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
 #define vpx_highbd_fdct32x32 vpx_highbd_fdct32x32_sse2
 
-void vpx_highbd_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct32x32_1 vpx_highbd_fdct32x32_1_c
 
-void vpx_highbd_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct32x32_rd_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_rd_c(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
+void vpx_highbd_fdct32x32_rd_sse2(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 #define vpx_highbd_fdct32x32_rd vpx_highbd_fdct32x32_rd_sse2
 
-void vpx_highbd_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_highbd_fdct4x4_sse2(const int16_t* input,
+                             tran_low_t* output,
+                             int stride);
 #define vpx_highbd_fdct4x4 vpx_highbd_fdct4x4_sse2
 
-void vpx_highbd_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct8x8_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_highbd_fdct8x8_sse2(const int16_t* input,
+                             tran_low_t* output,
+                             int stride);
 #define vpx_highbd_fdct8x8 vpx_highbd_fdct8x8_sse2
 
-void vpx_highbd_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_1_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
 #define vpx_highbd_fdct8x8_1 vpx_highbd_fdct8x8_1_c
 
-void vpx_highbd_h_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_16x16 vpx_highbd_h_predictor_16x16_c
 
-void vpx_highbd_h_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_32x32 vpx_highbd_h_predictor_32x32_c
 
-void vpx_highbd_h_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_4x4 vpx_highbd_h_predictor_4x4_c
 
-void vpx_highbd_h_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_8x8 vpx_highbd_h_predictor_8x8_c
 
-void vpx_highbd_idct16x16_10_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_10_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_10_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+void vpx_highbd_idct16x16_10_add_sse2(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
 #define vpx_highbd_idct16x16_10_add vpx_highbd_idct16x16_10_add_sse2
 
-void vpx_highbd_idct16x16_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
+void vpx_highbd_idct16x16_1_add_sse2(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
 #define vpx_highbd_idct16x16_1_add vpx_highbd_idct16x16_1_add_sse2
 
-void vpx_highbd_idct16x16_256_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_256_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t* input,
+                                       uint16_t* dest,
+                                       int stride,
+                                       int bd);
 #define vpx_highbd_idct16x16_256_add vpx_highbd_idct16x16_256_add_sse2
 
-void vpx_highbd_idct16x16_38_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-#define vpx_highbd_idct16x16_38_add vpx_highbd_idct16x16_256_add_sse2
+void vpx_highbd_idct16x16_38_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+void vpx_highbd_idct16x16_38_add_sse2(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+#define vpx_highbd_idct16x16_38_add vpx_highbd_idct16x16_38_add_sse2
 
-void vpx_highbd_idct32x32_1024_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1024_add_c(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
 #define vpx_highbd_idct32x32_1024_add vpx_highbd_idct32x32_1024_add_c
 
-void vpx_highbd_idct32x32_135_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_135_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
 #define vpx_highbd_idct32x32_135_add vpx_highbd_idct32x32_135_add_c
 
-void vpx_highbd_idct32x32_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct32x32_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
+void vpx_highbd_idct32x32_1_add_sse2(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
 #define vpx_highbd_idct32x32_1_add vpx_highbd_idct32x32_1_add_sse2
 
-void vpx_highbd_idct32x32_34_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_34_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct32x32_34_add vpx_highbd_idct32x32_34_add_c
 
-void vpx_highbd_idct4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_16_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_16_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct4x4_16_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct4x4_16_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct4x4_16_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct4x4_16_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_idct4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
+void vpx_highbd_idct4x4_1_add_sse2(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct4x4_1_add vpx_highbd_idct4x4_1_add_sse2
 
-void vpx_highbd_idct8x8_12_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_12_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_12_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_12_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_12_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct8x8_12_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct8x8_12_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_12_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_idct8x8_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
+void vpx_highbd_idct8x8_1_add_sse2(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct8x8_1_add vpx_highbd_idct8x8_1_add_sse2
 
-void vpx_highbd_idct8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_64_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_64_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_64_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_64_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct8x8_64_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct8x8_64_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_64_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_iwht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
 #define vpx_highbd_iwht4x4_16_add vpx_highbd_iwht4x4_16_add_c
 
-void vpx_highbd_iwht4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
 #define vpx_highbd_iwht4x4_1_add vpx_highbd_iwht4x4_1_add_c
 
-void vpx_highbd_lpf_horizontal_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_16_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_c(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
+void vpx_highbd_lpf_horizontal_16_sse2(uint16_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh,
+                                       int bd);
 #define vpx_highbd_lpf_horizontal_16 vpx_highbd_lpf_horizontal_16_sse2
 
-void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_16_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh,
+                                         int bd);
+void vpx_highbd_lpf_horizontal_16_dual_sse2(uint16_t* s,
+                                            int pitch,
+                                            const uint8_t* blimit,
+                                            const uint8_t* limit,
+                                            const uint8_t* thresh,
+                                            int bd);
 #define vpx_highbd_lpf_horizontal_16_dual vpx_highbd_lpf_horizontal_16_dual_sse2
 
-void vpx_highbd_lpf_horizontal_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_4_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_4_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
+void vpx_highbd_lpf_horizontal_4_sse2(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit,
+                                      const uint8_t* limit,
+                                      const uint8_t* thresh,
+                                      int bd);
 #define vpx_highbd_lpf_horizontal_4 vpx_highbd_lpf_horizontal_4_sse2
 
-void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_horizontal_4_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
+void vpx_highbd_lpf_horizontal_4_dual_sse2(uint16_t* s,
+                                           int pitch,
+                                           const uint8_t* blimit0,
+                                           const uint8_t* limit0,
+                                           const uint8_t* thresh0,
+                                           const uint8_t* blimit1,
+                                           const uint8_t* limit1,
+                                           const uint8_t* thresh1,
+                                           int bd);
 #define vpx_highbd_lpf_horizontal_4_dual vpx_highbd_lpf_horizontal_4_dual_sse2
 
-void vpx_highbd_lpf_horizontal_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_8_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_8_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
+void vpx_highbd_lpf_horizontal_8_sse2(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit,
+                                      const uint8_t* limit,
+                                      const uint8_t* thresh,
+                                      int bd);
 #define vpx_highbd_lpf_horizontal_8 vpx_highbd_lpf_horizontal_8_sse2
 
-void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_horizontal_8_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
+void vpx_highbd_lpf_horizontal_8_dual_sse2(uint16_t* s,
+                                           int pitch,
+                                           const uint8_t* blimit0,
+                                           const uint8_t* limit0,
+                                           const uint8_t* thresh0,
+                                           const uint8_t* blimit1,
+                                           const uint8_t* limit1,
+                                           const uint8_t* thresh1,
+                                           int bd);
 #define vpx_highbd_lpf_horizontal_8_dual vpx_highbd_lpf_horizontal_8_dual_sse2
 
-void vpx_highbd_lpf_vertical_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_16_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_c(uint16_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh,
+                                  int bd);
+void vpx_highbd_lpf_vertical_16_sse2(uint16_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh,
+                                     int bd);
 #define vpx_highbd_lpf_vertical_16 vpx_highbd_lpf_vertical_16_sse2
 
-void vpx_highbd_lpf_vertical_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_16_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_dual_c(uint16_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh,
+                                       int bd);
+void vpx_highbd_lpf_vertical_16_dual_sse2(uint16_t* s,
+                                          int pitch,
+                                          const uint8_t* blimit,
+                                          const uint8_t* limit,
+                                          const uint8_t* thresh,
+                                          int bd);
 #define vpx_highbd_lpf_vertical_16_dual vpx_highbd_lpf_vertical_16_dual_sse2
 
-void vpx_highbd_lpf_vertical_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_4_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_4_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
+void vpx_highbd_lpf_vertical_4_sse2(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
 #define vpx_highbd_lpf_vertical_4 vpx_highbd_lpf_vertical_4_sse2
 
-void vpx_highbd_lpf_vertical_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_vertical_4_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_4_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
+void vpx_highbd_lpf_vertical_4_dual_sse2(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit0,
+                                         const uint8_t* limit0,
+                                         const uint8_t* thresh0,
+                                         const uint8_t* blimit1,
+                                         const uint8_t* limit1,
+                                         const uint8_t* thresh1,
+                                         int bd);
 #define vpx_highbd_lpf_vertical_4_dual vpx_highbd_lpf_vertical_4_dual_sse2
 
-void vpx_highbd_lpf_vertical_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_8_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_8_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
+void vpx_highbd_lpf_vertical_8_sse2(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
 #define vpx_highbd_lpf_vertical_8 vpx_highbd_lpf_vertical_8_sse2
 
-void vpx_highbd_lpf_vertical_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_vertical_8_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_8_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
+void vpx_highbd_lpf_vertical_8_dual_sse2(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit0,
+                                         const uint8_t* limit0,
+                                         const uint8_t* thresh0,
+                                         const uint8_t* blimit1,
+                                         const uint8_t* limit1,
+                                         const uint8_t* thresh1,
+                                         int bd);
 #define vpx_highbd_lpf_vertical_8_dual vpx_highbd_lpf_vertical_8_dual_sse2
 
-void vpx_highbd_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_highbd_minmax_8x8_c(const uint8_t* s,
+                             int p,
+                             const uint8_t* d,
+                             int dp,
+                             int* min,
+                             int* max);
 #define vpx_highbd_minmax_8x8 vpx_highbd_minmax_8x8_c
 
-void vpx_highbd_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_highbd_quantize_b_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* zbin_ptr,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             const int16_t* quant_shift_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+void vpx_highbd_quantize_b_sse2(const tran_low_t* coeff_ptr,
+                                intptr_t n_coeffs,
+                                int skip_block,
+                                const int16_t* zbin_ptr,
+                                const int16_t* round_ptr,
+                                const int16_t* quant_ptr,
+                                const int16_t* quant_shift_ptr,
+                                tran_low_t* qcoeff_ptr,
+                                tran_low_t* dqcoeff_ptr,
+                                const int16_t* dequant_ptr,
+                                uint16_t* eob_ptr,
+                                const int16_t* scan,
+                                const int16_t* iscan);
 #define vpx_highbd_quantize_b vpx_highbd_quantize_b_sse2
 
-void vpx_highbd_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_highbd_quantize_b_32x32_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
+void vpx_highbd_quantize_b_32x32_sse2(const tran_low_t* coeff_ptr,
+                                      intptr_t n_coeffs,
+                                      int skip_block,
+                                      const int16_t* zbin_ptr,
+                                      const int16_t* round_ptr,
+                                      const int16_t* quant_ptr,
+                                      const int16_t* quant_shift_ptr,
+                                      tran_low_t* qcoeff_ptr,
+                                      tran_low_t* dqcoeff_ptr,
+                                      const int16_t* dequant_ptr,
+                                      uint16_t* eob_ptr,
+                                      const int16_t* scan,
+                                      const int16_t* iscan);
 #define vpx_highbd_quantize_b_32x32 vpx_highbd_quantize_b_32x32_sse2
 
-unsigned int vpx_highbd_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad16x16_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad16x16 vpx_highbd_sad16x16_sse2
 
-unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x16_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad16x16_avg vpx_highbd_sad16x16_avg_sse2
 
-void vpx_highbd_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad16x16x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad16x16x4d vpx_highbd_sad16x16x4d_sse2
 
-unsigned int vpx_highbd_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad16x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad16x32 vpx_highbd_sad16x32_sse2
 
-unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad16x32_avg vpx_highbd_sad16x32_avg_sse2
 
-void vpx_highbd_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad16x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad16x32x4d vpx_highbd_sad16x32x4d_sse2
 
-unsigned int vpx_highbd_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x8_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int vpx_highbd_sad16x8_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
 #define vpx_highbd_sad16x8 vpx_highbd_sad16x8_sse2
 
-unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x8_avg_sse2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         const uint8_t* second_pred);
 #define vpx_highbd_sad16x8_avg vpx_highbd_sad16x8_avg_sse2
 
-void vpx_highbd_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x8x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void vpx_highbd_sad16x8x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
 #define vpx_highbd_sad16x8x4d vpx_highbd_sad16x8x4d_sse2
 
-unsigned int vpx_highbd_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x16_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad32x16 vpx_highbd_sad32x16_sse2
 
-unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x16_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad32x16_avg vpx_highbd_sad32x16_avg_sse2
 
-void vpx_highbd_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x16x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad32x16x4d vpx_highbd_sad32x16x4d_sse2
 
-unsigned int vpx_highbd_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad32x32 vpx_highbd_sad32x32_sse2
 
-unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad32x32_avg vpx_highbd_sad32x32_avg_sse2
 
-void vpx_highbd_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad32x32x4d vpx_highbd_sad32x32x4d_sse2
 
-unsigned int vpx_highbd_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad32x64 vpx_highbd_sad32x64_sse2
 
-unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x64_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad32x64_avg vpx_highbd_sad32x64_avg_sse2
 
-void vpx_highbd_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad32x64x4d vpx_highbd_sad32x64x4d_sse2
 
-unsigned int vpx_highbd_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x4 vpx_highbd_sad4x4_c
 
-unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x4_avg vpx_highbd_sad4x4_avg_c
 
-void vpx_highbd_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad4x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad4x4x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
 #define vpx_highbd_sad4x4x4d vpx_highbd_sad4x4x4d_sse2
 
-unsigned int vpx_highbd_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x8 vpx_highbd_sad4x8_c
 
-unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x8_avg vpx_highbd_sad4x8_avg_c
 
-void vpx_highbd_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad4x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad4x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
 #define vpx_highbd_sad4x8x4d vpx_highbd_sad4x8x4d_sse2
 
-unsigned int vpx_highbd_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad64x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad64x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad64x32 vpx_highbd_sad64x32_sse2
 
-unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad64x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad64x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad64x32_avg vpx_highbd_sad64x32_avg_sse2
 
-void vpx_highbd_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad64x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad64x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad64x32x4d vpx_highbd_sad64x32x4d_sse2
 
-unsigned int vpx_highbd_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad64x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad64x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad64x64 vpx_highbd_sad64x64_sse2
 
-unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad64x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad64x64_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad64x64_avg vpx_highbd_sad64x64_avg_sse2
 
-void vpx_highbd_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad64x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad64x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad64x64x4d vpx_highbd_sad64x64x4d_sse2
 
-unsigned int vpx_highbd_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int vpx_highbd_sad8x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
 #define vpx_highbd_sad8x16 vpx_highbd_sad8x16_sse2
 
-unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x16_avg_sse2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         const uint8_t* second_pred);
 #define vpx_highbd_sad8x16_avg vpx_highbd_sad8x16_avg_sse2
 
-void vpx_highbd_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void vpx_highbd_sad8x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
 #define vpx_highbd_sad8x16x4d vpx_highbd_sad8x16x4d_sse2
 
-unsigned int vpx_highbd_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int vpx_highbd_sad8x4_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
 #define vpx_highbd_sad8x4 vpx_highbd_sad8x4_sse2
 
-unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x4_avg_sse2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        const uint8_t* second_pred);
 #define vpx_highbd_sad8x4_avg vpx_highbd_sad8x4_avg_sse2
 
-void vpx_highbd_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad8x4x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
 #define vpx_highbd_sad8x4x4d vpx_highbd_sad8x4x4d_sse2
 
-unsigned int vpx_highbd_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int vpx_highbd_sad8x8_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
 #define vpx_highbd_sad8x8 vpx_highbd_sad8x8_sse2
 
-unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x8_avg_sse2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        const uint8_t* second_pred);
 #define vpx_highbd_sad8x8_avg vpx_highbd_sad8x8_avg_sse2
 
-void vpx_highbd_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad8x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
 #define vpx_highbd_sad8x8x4d vpx_highbd_sad8x8x4d_sse2
 
-void vpx_highbd_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride, int bd);
+void vpx_highbd_subtract_block_c(int rows,
+                                 int cols,
+                                 int16_t* diff_ptr,
+                                 ptrdiff_t diff_stride,
+                                 const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 const uint8_t* pred_ptr,
+                                 ptrdiff_t pred_stride,
+                                 int bd);
 #define vpx_highbd_subtract_block vpx_highbd_subtract_block_c
 
-void vpx_highbd_tm_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_tm_predictor_16x16_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_tm_predictor_16x16 vpx_highbd_tm_predictor_16x16_sse2
 
-void vpx_highbd_tm_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_tm_predictor_32x32_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_tm_predictor_32x32 vpx_highbd_tm_predictor_32x32_sse2
 
-void vpx_highbd_tm_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_tm_predictor_4x4_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_tm_predictor_4x4 vpx_highbd_tm_predictor_4x4_sse2
 
-void vpx_highbd_tm_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_tm_predictor_8x8_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_tm_predictor_8x8 vpx_highbd_tm_predictor_8x8_sse2
 
-void vpx_highbd_v_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
+void vpx_highbd_v_predictor_16x16_sse2(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_v_predictor_16x16 vpx_highbd_v_predictor_16x16_sse2
 
-void vpx_highbd_v_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
+void vpx_highbd_v_predictor_32x32_sse2(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_v_predictor_32x32 vpx_highbd_v_predictor_32x32_sse2
 
-void vpx_highbd_v_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
+void vpx_highbd_v_predictor_4x4_sse2(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_v_predictor_4x4 vpx_highbd_v_predictor_4x4_sse2
 
-void vpx_highbd_v_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
+void vpx_highbd_v_predictor_8x8_sse2(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_v_predictor_8x8 vpx_highbd_v_predictor_8x8_sse2
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_10_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_10_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct16x16_10_add vpx_idct16x16_10_add_sse2
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_1_add_sse2(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct16x16_1_add vpx_idct16x16_1_add_sse2
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_256_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct16x16_256_add_sse2(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
 #define vpx_idct16x16_256_add vpx_idct16x16_256_add_sse2
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_38_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_38_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct16x16_38_add vpx_idct16x16_38_add_sse2
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+void vpx_idct32x32_1024_add_sse2(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
 #define vpx_idct32x32_1024_add vpx_idct32x32_1024_add_sse2
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_135_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_135_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct32x32_1024_add_sse2(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+void vpx_idct32x32_135_add_ssse3(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+RTCD_EXTERN void (*vpx_idct32x32_135_add)(const tran_low_t* input,
+                                          uint8_t* dest,
+                                          int stride);
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_1_add_sse2(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct32x32_1_add vpx_idct32x32_1_add_sse2
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_34_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_34_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+void vpx_idct32x32_34_add_ssse3(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
+RTCD_EXTERN void (*vpx_idct32x32_34_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_16_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct4x4_16_add vpx_idct4x4_16_add_sse2
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_1_add_sse2(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_1_add vpx_idct4x4_1_add_sse2
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_12_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_12_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct8x8_12_add_ssse3(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+RTCD_EXTERN void (*vpx_idct8x8_12_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_1_add_sse2(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_1_add vpx_idct8x8_1_add_sse2
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_64_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_64_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct8x8_64_add vpx_idct8x8_64_add_sse2
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
-int16_t vpx_int_pro_col_sse2(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
+int16_t vpx_int_pro_col_sse2(const uint8_t* ref, const int width);
 #define vpx_int_pro_col vpx_int_pro_col_sse2
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-void vpx_int_pro_row_sse2(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
+void vpx_int_pro_row_sse2(int16_t* hbuf,
+                          const uint8_t* ref,
+                          const int ref_stride,
+                          const int height);
 #define vpx_int_pro_row vpx_int_pro_row_sse2
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_iwht4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_iwht4x4_16_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_iwht4x4_16_add vpx_iwht4x4_16_add_sse2
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_avx2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_16)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+void vpx_lpf_horizontal_16_sse2(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_horizontal_16_avx2(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_16)(uint8_t* s,
+                                          int pitch,
+                                          const uint8_t* blimit,
+                                          const uint8_t* limit,
+                                          const uint8_t* thresh);
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_avx2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_16_dual)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_sse2(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_avx2(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_16_dual)(uint8_t* s,
+                                               int pitch,
+                                               const uint8_t* blimit,
+                                               const uint8_t* limit,
+                                               const uint8_t* thresh);
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_4_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_4_sse2(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
 #define vpx_lpf_horizontal_4 vpx_lpf_horizontal_4_sse2
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_4_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_4_dual_sse2(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
 #define vpx_lpf_horizontal_4_dual vpx_lpf_horizontal_4_dual_sse2
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_8_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_8_sse2(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
 #define vpx_lpf_horizontal_8 vpx_lpf_horizontal_8_sse2
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_8_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_8_dual_sse2(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
 #define vpx_lpf_horizontal_8_dual vpx_lpf_horizontal_8_dual_sse2
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
+void vpx_lpf_vertical_16_sse2(uint8_t* s,
+                              int pitch,
+                              const uint8_t* blimit,
+                              const uint8_t* limit,
+                              const uint8_t* thresh);
 #define vpx_lpf_vertical_16 vpx_lpf_vertical_16_sse2
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_vertical_16_dual_sse2(uint8_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh);
 #define vpx_lpf_vertical_16_dual vpx_lpf_vertical_16_dual_sse2
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_4_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_4_sse2(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_vertical_4 vpx_lpf_vertical_4_sse2
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_4_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_4_dual_sse2(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
 #define vpx_lpf_vertical_4_dual vpx_lpf_vertical_4_dual_sse2
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_8_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_8_sse2(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_vertical_8 vpx_lpf_vertical_8_sse2
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_8_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_8_dual_sse2(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
 #define vpx_lpf_vertical_8_dual vpx_lpf_vertical_8_dual_sse2
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_across_ip_sse2(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
+void vpx_mbpost_proc_across_ip_sse2(unsigned char* dst,
+                                    int pitch,
+                                    int rows,
+                                    int cols,
+                                    int flimit);
 #define vpx_mbpost_proc_across_ip vpx_mbpost_proc_across_ip_sse2
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_down_sse2(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
+void vpx_mbpost_proc_down_sse2(unsigned char* dst,
+                               int pitch,
+                               int rows,
+                               int cols,
+                               int flimit);
 #define vpx_mbpost_proc_down vpx_mbpost_proc_down_sse2
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-void vpx_minmax_8x8_sse2(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
+void vpx_minmax_8x8_sse2(const uint8_t* s,
+                         int p,
+                         const uint8_t* d,
+                         int dp,
+                         int* min,
+                         int* max);
 #define vpx_minmax_8x8 vpx_minmax_8x8_sse2
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_avx2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
+unsigned int vpx_mse16x16_sse2(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
+unsigned int vpx_mse16x16_avx2(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse16x16)(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
+unsigned int vpx_mse16x8_sse2(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int recon_stride,
+                              unsigned int* sse);
 #define vpx_mse16x8 vpx_mse16x8_sse2
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse8x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
+unsigned int vpx_mse8x16_sse2(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int recon_stride,
+                              unsigned int* sse);
 #define vpx_mse8x16 vpx_mse8x16_sse2
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
+unsigned int vpx_mse8x8_sse2(const uint8_t* src_ptr,
+                             int source_stride,
+                             const uint8_t* ref_ptr,
+                             int recon_stride,
+                             unsigned int* sse);
 #define vpx_mse8x8 vpx_mse8x8_sse2
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
-void vpx_plane_add_noise_sse2(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
+void vpx_plane_add_noise_sse2(uint8_t* start,
+                              const int8_t* noise,
+                              int blackclamp,
+                              int whiteclamp,
+                              int width,
+                              int height,
+                              int pitch);
 #define vpx_plane_add_noise vpx_plane_add_noise_sse2
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-void vpx_post_proc_down_and_across_mb_row_sse2(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-#define vpx_post_proc_down_and_across_mb_row vpx_post_proc_down_and_across_mb_row_sse2
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+void vpx_post_proc_down_and_across_mb_row_sse2(unsigned char* src,
+                                               unsigned char* dst,
+                                               int src_pitch,
+                                               int dst_pitch,
+                                               int cols,
+                                               unsigned char* flimits,
+                                               int size);
+#define vpx_post_proc_down_and_across_mb_row \
+  vpx_post_proc_down_and_across_mb_row_sse2
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_ssse3(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_avx(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_quantize_b)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
+void vpx_quantize_b_sse2(const tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* zbin_ptr,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         const int16_t* quant_shift_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+void vpx_quantize_b_ssse3(const tran_low_t* coeff_ptr,
+                          intptr_t n_coeffs,
+                          int skip_block,
+                          const int16_t* zbin_ptr,
+                          const int16_t* round_ptr,
+                          const int16_t* quant_ptr,
+                          const int16_t* quant_shift_ptr,
+                          tran_low_t* qcoeff_ptr,
+                          tran_low_t* dqcoeff_ptr,
+                          const int16_t* dequant_ptr,
+                          uint16_t* eob_ptr,
+                          const int16_t* scan,
+                          const int16_t* iscan);
+void vpx_quantize_b_avx(const tran_low_t* coeff_ptr,
+                        intptr_t n_coeffs,
+                        int skip_block,
+                        const int16_t* zbin_ptr,
+                        const int16_t* round_ptr,
+                        const int16_t* quant_ptr,
+                        const int16_t* quant_shift_ptr,
+                        tran_low_t* qcoeff_ptr,
+                        tran_low_t* dqcoeff_ptr,
+                        const int16_t* dequant_ptr,
+                        uint16_t* eob_ptr,
+                        const int16_t* scan,
+                        const int16_t* iscan);
+RTCD_EXTERN void (*vpx_quantize_b)(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_32x32_ssse3(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_32x32_avx(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_quantize_b_32x32)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
+void vpx_quantize_b_32x32_ssse3(const tran_low_t* coeff_ptr,
+                                intptr_t n_coeffs,
+                                int skip_block,
+                                const int16_t* zbin_ptr,
+                                const int16_t* round_ptr,
+                                const int16_t* quant_ptr,
+                                const int16_t* quant_shift_ptr,
+                                tran_low_t* qcoeff_ptr,
+                                tran_low_t* dqcoeff_ptr,
+                                const int16_t* dequant_ptr,
+                                uint16_t* eob_ptr,
+                                const int16_t* scan,
+                                const int16_t* iscan);
+void vpx_quantize_b_32x32_avx(const tran_low_t* coeff_ptr,
+                              intptr_t n_coeffs,
+                              int skip_block,
+                              const int16_t* zbin_ptr,
+                              const int16_t* round_ptr,
+                              const int16_t* quant_ptr,
+                              const int16_t* quant_shift_ptr,
+                              tran_low_t* qcoeff_ptr,
+                              tran_low_t* dqcoeff_ptr,
+                              const int16_t* dequant_ptr,
+                              uint16_t* eob_ptr,
+                              const int16_t* scan,
+                              const int16_t* iscan);
+RTCD_EXTERN void (*vpx_quantize_b_32x32)(const tran_low_t* coeff_ptr,
+                                         intptr_t n_coeffs,
+                                         int skip_block,
+                                         const int16_t* zbin_ptr,
+                                         const int16_t* round_ptr,
+                                         const int16_t* quant_ptr,
+                                         const int16_t* quant_shift_ptr,
+                                         tran_low_t* qcoeff_ptr,
+                                         tran_low_t* dqcoeff_ptr,
+                                         const int16_t* dequant_ptr,
+                                         uint16_t* eob_ptr,
+                                         const int16_t* scan,
+                                         const int16_t* iscan);
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x16_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad16x16 vpx_sad16x16_sse2
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x16_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad16x16_avg vpx_sad16x16_avg_sse2
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x3_ssse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x16x3_sse3(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+void vpx_sad16x16x3_ssse3(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x3)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x16x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad16x16x4d vpx_sad16x16x4d_sse2
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x16x8_sse4_1(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride,
+                           uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x8)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad16x32 vpx_sad16x32_sse2
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad16x32_avg vpx_sad16x32_avg_sse2
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad16x32x4d vpx_sad16x32x4d_sse2
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad16x8_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
 #define vpx_sad16x8 vpx_sad16x8_sse2
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad16x8_avg_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
 #define vpx_sad16x8_avg vpx_sad16x8_avg_sse2
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x3_ssse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad16x8x3_sse3(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        uint32_t* sad_array);
+void vpx_sad16x8x3_ssse3(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x3)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x8x4d_sse2(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
 #define vpx_sad16x8x4d vpx_sad16x8x4d_sse2
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad16x8x8_sse4_1(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x8)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x16_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x16_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x16)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x16_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x16x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x16x4d vpx_sad32x16x4d_sse2
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x32_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+void vpx_sad32x32x4d_avx2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x64_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x64_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x64)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x64_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x64x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x64x4d vpx_sad32x64x4d_sse2
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x4_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad4x4 vpx_sad4x4_sse2
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x4_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad4x4_avg vpx_sad4x4_avg_sse2
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad4x4x3_sse3(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x3)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x4x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad4x4x4d vpx_sad4x4x4d_sse2
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad4x4x8_sse4_1(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x8)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x8_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad4x8 vpx_sad4x8_sse2
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x8_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad4x8_avg vpx_sad4x8_avg_sse2
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x8x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad4x8x4d vpx_sad4x8x4d_sse2
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad64x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad64x32_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad64x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad64x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad64x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad64x32x4d vpx_sad64x32x4d_sse2
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad64x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x64_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad64x64_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad64x64)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad64x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad64x64_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad64x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x64x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+void vpx_sad64x64x4d_avx2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad64x64x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad8x16_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
 #define vpx_sad8x16 vpx_sad8x16_sse2
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad8x16_avg_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
 #define vpx_sad8x16_avg vpx_sad8x16_avg_sse2
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x16x3_sse3(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x3)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad8x16x4d_sse2(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
 #define vpx_sad8x16x4d vpx_sad8x16x4d_sse2
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x16x8_sse4_1(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x8)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x4_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad8x4 vpx_sad8x4_sse2
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x4_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad8x4_avg vpx_sad8x4_avg_sse2
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x4x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad8x4x4d vpx_sad8x4x4d_sse2
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x8_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad8x8 vpx_sad8x8_sse2
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x8_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad8x8_avg vpx_sad8x8_avg_sse2
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad8x8x3_sse3(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x3)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x8x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad8x8x4d vpx_sad8x8x4d_sse2
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad8x8x8_sse4_1(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x8)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-int vpx_satd_c(const tran_low_t *coeff, int length);
-int vpx_satd_sse2(const tran_low_t *coeff, int length);
+int vpx_satd_c(const tran_low_t* coeff, int length);
+int vpx_satd_sse2(const tran_low_t* coeff, int length);
 #define vpx_satd vpx_satd_sse2
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_scaled_2d_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_scaled_2d)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_scaled_2d_ssse3(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+RTCD_EXTERN void (*vpx_scaled_2d)(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_ssse3(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_avx2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_avx2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_ssse3(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x16)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_ssse3(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x8)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x16)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_avx2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x64)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x4)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x8)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_avx2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x64)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_ssse3(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x16)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x4)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x8)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-void vpx_subtract_block_sse2(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
+void vpx_subtract_block_sse2(int rows,
+                             int cols,
+                             int16_t* diff_ptr,
+                             ptrdiff_t diff_stride,
+                             const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             const uint8_t* pred_ptr,
+                             ptrdiff_t pred_stride);
 #define vpx_subtract_block vpx_subtract_block_sse2
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
-uint64_t vpx_sum_squares_2d_i16_sse2(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_sse2(const int16_t* src, int stride, int size);
 #define vpx_sum_squares_2d_i16 vpx_sum_squares_2d_i16_sse2
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_16x16_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_tm_predictor_16x16 vpx_tm_predictor_16x16_sse2
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_32x32_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_tm_predictor_32x32 vpx_tm_predictor_32x32_sse2
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_4x4_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_tm_predictor_4x4 vpx_tm_predictor_4x4_sse2
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_8x8_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_tm_predictor_8x8 vpx_tm_predictor_8x8_sse2
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_16x16_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_v_predictor_16x16 vpx_v_predictor_16x16_sse2
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_32x32_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_v_predictor_32x32 vpx_v_predictor_32x32_sse2
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_4x4_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_v_predictor_4x4 vpx_v_predictor_4x4_sse2
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_8x8_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_v_predictor_8x8 vpx_v_predictor_8x8_sse2
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x16_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance16x16_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x16)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance16x32 vpx_variance16x32_sse2
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance16x8_sse2(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
 #define vpx_variance16x8 vpx_variance16x8_sse2
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x16_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance32x16_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x16)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance32x32_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x64_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x64 vpx_variance32x64_sse2
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x4_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance4x4 vpx_variance4x4_sse2
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x8_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance4x8 vpx_variance4x8_sse2
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance64x32_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance64x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x64_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance64x64_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance64x64)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance8x16_sse2(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
 #define vpx_variance8x16 vpx_variance8x16_sse2
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x4_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance8x4 vpx_variance8x4_sse2
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x8_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance8x8 vpx_variance8x8_sse2
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
-int vpx_vector_var_sse2(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
+int vpx_vector_var_sse2(const int16_t* ref, const int16_t* src, const int bwl);
 #define vpx_vector_var vpx_vector_var_sse2
 
 void vpx_dsp_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vpx_convolve8 = vpx_convolve8_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8 = vpx_convolve8_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8 = vpx_convolve8_avx2;
-    vpx_convolve8_avg = vpx_convolve8_avg_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg = vpx_convolve8_avg_ssse3;
-    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_ssse3;
-    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_ssse3;
-    vpx_convolve8_horiz = vpx_convolve8_horiz_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_horiz = vpx_convolve8_horiz_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8_horiz = vpx_convolve8_horiz_avx2;
-    vpx_convolve8_vert = vpx_convolve8_vert_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_vert = vpx_convolve8_vert_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8_vert = vpx_convolve8_vert_avx2;
-    vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_ssse3;
-    vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_ssse3;
-    vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_ssse3;
-    vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_ssse3;
-    vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_ssse3;
-    vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_ssse3;
-    vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_ssse3;
-    vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_ssse3;
-    vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_ssse3;
-    vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_ssse3;
-    vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_ssse3;
-    vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_ssse3;
-    vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_ssse3;
-    vpx_get16x16var = vpx_get16x16var_sse2;
-    if (flags & HAS_AVX2) vpx_get16x16var = vpx_get16x16var_avx2;
-    vpx_hadamard_8x8 = vpx_hadamard_8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_hadamard_8x8 = vpx_hadamard_8x8_ssse3;
-    vpx_highbd_convolve8 = vpx_highbd_convolve8_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8 = vpx_highbd_convolve8_avx2;
-    vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_avx2;
-    vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_avx2;
-    vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_avx2;
-    vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_avx2;
-    vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_avx2;
-    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_avx2;
-    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_avx2;
-    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse4_1;
-    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse4_1;
-    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse4_1;
-    vpx_idct32x32_135_add = vpx_idct32x32_1024_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct32x32_135_add = vpx_idct32x32_135_add_ssse3;
-    vpx_idct32x32_34_add = vpx_idct32x32_34_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct32x32_34_add = vpx_idct32x32_34_add_ssse3;
-    vpx_idct8x8_12_add = vpx_idct8x8_12_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct8x8_12_add = vpx_idct8x8_12_add_ssse3;
-    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_sse2;
-    if (flags & HAS_AVX2) vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_avx2;
-    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_sse2;
-    if (flags & HAS_AVX2) vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_avx2;
-    vpx_mse16x16 = vpx_mse16x16_sse2;
-    if (flags & HAS_AVX2) vpx_mse16x16 = vpx_mse16x16_avx2;
-    vpx_quantize_b = vpx_quantize_b_sse2;
-    if (flags & HAS_SSSE3) vpx_quantize_b = vpx_quantize_b_ssse3;
-    if (flags & HAS_AVX) vpx_quantize_b = vpx_quantize_b_avx;
-    vpx_quantize_b_32x32 = vpx_quantize_b_32x32_c;
-    if (flags & HAS_SSSE3) vpx_quantize_b_32x32 = vpx_quantize_b_32x32_ssse3;
-    if (flags & HAS_AVX) vpx_quantize_b_32x32 = vpx_quantize_b_32x32_avx;
-    vpx_sad16x16x3 = vpx_sad16x16x3_c;
-    if (flags & HAS_SSE3) vpx_sad16x16x3 = vpx_sad16x16x3_sse3;
-    if (flags & HAS_SSSE3) vpx_sad16x16x3 = vpx_sad16x16x3_ssse3;
-    vpx_sad16x16x8 = vpx_sad16x16x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad16x16x8 = vpx_sad16x16x8_sse4_1;
-    vpx_sad16x8x3 = vpx_sad16x8x3_c;
-    if (flags & HAS_SSE3) vpx_sad16x8x3 = vpx_sad16x8x3_sse3;
-    if (flags & HAS_SSSE3) vpx_sad16x8x3 = vpx_sad16x8x3_ssse3;
-    vpx_sad16x8x8 = vpx_sad16x8x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad16x8x8 = vpx_sad16x8x8_sse4_1;
-    vpx_sad32x16 = vpx_sad32x16_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x16 = vpx_sad32x16_avx2;
-    vpx_sad32x16_avg = vpx_sad32x16_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x16_avg = vpx_sad32x16_avg_avx2;
-    vpx_sad32x32 = vpx_sad32x32_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32 = vpx_sad32x32_avx2;
-    vpx_sad32x32_avg = vpx_sad32x32_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32_avg = vpx_sad32x32_avg_avx2;
-    vpx_sad32x32x4d = vpx_sad32x32x4d_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32x4d = vpx_sad32x32x4d_avx2;
-    vpx_sad32x64 = vpx_sad32x64_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x64 = vpx_sad32x64_avx2;
-    vpx_sad32x64_avg = vpx_sad32x64_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x64_avg = vpx_sad32x64_avg_avx2;
-    vpx_sad4x4x3 = vpx_sad4x4x3_c;
-    if (flags & HAS_SSE3) vpx_sad4x4x3 = vpx_sad4x4x3_sse3;
-    vpx_sad4x4x8 = vpx_sad4x4x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad4x4x8 = vpx_sad4x4x8_sse4_1;
-    vpx_sad64x32 = vpx_sad64x32_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x32 = vpx_sad64x32_avx2;
-    vpx_sad64x32_avg = vpx_sad64x32_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x32_avg = vpx_sad64x32_avg_avx2;
-    vpx_sad64x64 = vpx_sad64x64_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64 = vpx_sad64x64_avx2;
-    vpx_sad64x64_avg = vpx_sad64x64_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64_avg = vpx_sad64x64_avg_avx2;
-    vpx_sad64x64x4d = vpx_sad64x64x4d_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64x4d = vpx_sad64x64x4d_avx2;
-    vpx_sad8x16x3 = vpx_sad8x16x3_c;
-    if (flags & HAS_SSE3) vpx_sad8x16x3 = vpx_sad8x16x3_sse3;
-    vpx_sad8x16x8 = vpx_sad8x16x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad8x16x8 = vpx_sad8x16x8_sse4_1;
-    vpx_sad8x8x3 = vpx_sad8x8x3_c;
-    if (flags & HAS_SSE3) vpx_sad8x8x3 = vpx_sad8x8x3_sse3;
-    vpx_sad8x8x8 = vpx_sad8x8x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad8x8x8 = vpx_sad8x8x8_sse4_1;
-    vpx_scaled_2d = vpx_scaled_2d_c;
-    if (flags & HAS_SSSE3) vpx_scaled_2d = vpx_scaled_2d_ssse3;
-    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_ssse3;
-    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_ssse3;
-    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_ssse3;
-    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_ssse3;
-    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_avx2;
-    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_ssse3;
-    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_ssse3;
-    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_ssse3;
-    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_ssse3;
-    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_avx2;
-    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_ssse3;
-    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_ssse3;
-    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_ssse3;
-    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_ssse3;
-    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_ssse3;
-    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_ssse3;
-    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_ssse3;
-    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_avx2;
-    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_ssse3;
-    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_ssse3;
-    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_ssse3;
-    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_ssse3;
-    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_avx2;
-    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_ssse3;
-    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_ssse3;
-    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_ssse3;
-    vpx_variance16x16 = vpx_variance16x16_sse2;
-    if (flags & HAS_AVX2) vpx_variance16x16 = vpx_variance16x16_avx2;
-    vpx_variance32x16 = vpx_variance32x16_sse2;
-    if (flags & HAS_AVX2) vpx_variance32x16 = vpx_variance32x16_avx2;
-    vpx_variance32x32 = vpx_variance32x32_sse2;
-    if (flags & HAS_AVX2) vpx_variance32x32 = vpx_variance32x32_avx2;
-    vpx_variance64x32 = vpx_variance64x32_sse2;
-    if (flags & HAS_AVX2) vpx_variance64x32 = vpx_variance64x32_avx2;
-    vpx_variance64x64 = vpx_variance64x64_sse2;
-    if (flags & HAS_AVX2) vpx_variance64x64 = vpx_variance64x64_avx2;
+  vpx_convolve8 = vpx_convolve8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8 = vpx_convolve8_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8 = vpx_convolve8_avx2;
+  vpx_convolve8_avg = vpx_convolve8_avg_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg = vpx_convolve8_avg_ssse3;
+  vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_ssse3;
+  vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_ssse3;
+  vpx_convolve8_horiz = vpx_convolve8_horiz_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_avx2;
+  vpx_convolve8_vert = vpx_convolve8_vert_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_vert = vpx_convolve8_vert_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8_vert = vpx_convolve8_vert_avx2;
+  vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_ssse3;
+  vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_ssse3;
+  vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_ssse3;
+  vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_ssse3;
+  vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_ssse3;
+  vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_ssse3;
+  vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_ssse3;
+  vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_ssse3;
+  vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_ssse3;
+  vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_ssse3;
+  vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_ssse3;
+  vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_ssse3;
+  vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_ssse3;
+  vpx_get16x16var = vpx_get16x16var_sse2;
+  if (flags & HAS_AVX2)
+    vpx_get16x16var = vpx_get16x16var_avx2;
+  vpx_hadamard_8x8 = vpx_hadamard_8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_hadamard_8x8 = vpx_hadamard_8x8_ssse3;
+  vpx_highbd_convolve8 = vpx_highbd_convolve8_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8 = vpx_highbd_convolve8_avx2;
+  vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_avx2;
+  vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_avx2;
+  vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_avx2;
+  vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_avx2;
+  vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_avx2;
+  vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_avx2;
+  vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_avx2;
+  vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse4_1;
+  vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse4_1;
+  vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse4_1;
+  vpx_idct32x32_135_add = vpx_idct32x32_1024_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct32x32_135_add = vpx_idct32x32_135_add_ssse3;
+  vpx_idct32x32_34_add = vpx_idct32x32_34_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct32x32_34_add = vpx_idct32x32_34_add_ssse3;
+  vpx_idct8x8_12_add = vpx_idct8x8_12_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct8x8_12_add = vpx_idct8x8_12_add_ssse3;
+  vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_avx2;
+  vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_sse2;
+  if (flags & HAS_AVX2)
+    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_avx2;
+  vpx_mse16x16 = vpx_mse16x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_mse16x16 = vpx_mse16x16_avx2;
+  vpx_quantize_b = vpx_quantize_b_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_quantize_b = vpx_quantize_b_ssse3;
+  if (flags & HAS_AVX)
+    vpx_quantize_b = vpx_quantize_b_avx;
+  vpx_quantize_b_32x32 = vpx_quantize_b_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_quantize_b_32x32 = vpx_quantize_b_32x32_ssse3;
+  if (flags & HAS_AVX)
+    vpx_quantize_b_32x32 = vpx_quantize_b_32x32_avx;
+  vpx_sad16x16x3 = vpx_sad16x16x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad16x16x3 = vpx_sad16x16x3_sse3;
+  if (flags & HAS_SSSE3)
+    vpx_sad16x16x3 = vpx_sad16x16x3_ssse3;
+  vpx_sad16x16x8 = vpx_sad16x16x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad16x16x8 = vpx_sad16x16x8_sse4_1;
+  vpx_sad16x8x3 = vpx_sad16x8x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad16x8x3 = vpx_sad16x8x3_sse3;
+  if (flags & HAS_SSSE3)
+    vpx_sad16x8x3 = vpx_sad16x8x3_ssse3;
+  vpx_sad16x8x8 = vpx_sad16x8x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad16x8x8 = vpx_sad16x8x8_sse4_1;
+  vpx_sad32x16 = vpx_sad32x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x16 = vpx_sad32x16_avx2;
+  vpx_sad32x16_avg = vpx_sad32x16_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x16_avg = vpx_sad32x16_avg_avx2;
+  vpx_sad32x32 = vpx_sad32x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32 = vpx_sad32x32_avx2;
+  vpx_sad32x32_avg = vpx_sad32x32_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32_avg = vpx_sad32x32_avg_avx2;
+  vpx_sad32x32x4d = vpx_sad32x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32x4d = vpx_sad32x32x4d_avx2;
+  vpx_sad32x64 = vpx_sad32x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x64 = vpx_sad32x64_avx2;
+  vpx_sad32x64_avg = vpx_sad32x64_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x64_avg = vpx_sad32x64_avg_avx2;
+  vpx_sad4x4x3 = vpx_sad4x4x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad4x4x3 = vpx_sad4x4x3_sse3;
+  vpx_sad4x4x8 = vpx_sad4x4x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad4x4x8 = vpx_sad4x4x8_sse4_1;
+  vpx_sad64x32 = vpx_sad64x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x32 = vpx_sad64x32_avx2;
+  vpx_sad64x32_avg = vpx_sad64x32_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x32_avg = vpx_sad64x32_avg_avx2;
+  vpx_sad64x64 = vpx_sad64x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64 = vpx_sad64x64_avx2;
+  vpx_sad64x64_avg = vpx_sad64x64_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64_avg = vpx_sad64x64_avg_avx2;
+  vpx_sad64x64x4d = vpx_sad64x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64x4d = vpx_sad64x64x4d_avx2;
+  vpx_sad8x16x3 = vpx_sad8x16x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad8x16x3 = vpx_sad8x16x3_sse3;
+  vpx_sad8x16x8 = vpx_sad8x16x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad8x16x8 = vpx_sad8x16x8_sse4_1;
+  vpx_sad8x8x3 = vpx_sad8x8x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad8x8x3 = vpx_sad8x8x3_sse3;
+  vpx_sad8x8x8 = vpx_sad8x8x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad8x8x8 = vpx_sad8x8x8_sse4_1;
+  vpx_scaled_2d = vpx_scaled_2d_c;
+  if (flags & HAS_SSSE3)
+    vpx_scaled_2d = vpx_scaled_2d_ssse3;
+  vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_ssse3;
+  vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_ssse3;
+  vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_ssse3;
+  vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_ssse3;
+  vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_avx2;
+  vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_ssse3;
+  vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_ssse3;
+  vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_ssse3;
+  vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_ssse3;
+  vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_avx2;
+  vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_ssse3;
+  vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_ssse3;
+  vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_ssse3;
+  vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_ssse3;
+  vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_ssse3;
+  vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_ssse3;
+  vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_ssse3;
+  vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_avx2;
+  vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_ssse3;
+  vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_ssse3;
+  vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_ssse3;
+  vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_ssse3;
+  vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_avx2;
+  vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_ssse3;
+  vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_ssse3;
+  vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_ssse3;
+  vpx_variance16x16 = vpx_variance16x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance16x16 = vpx_variance16x16_avx2;
+  vpx_variance32x16 = vpx_variance32x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance32x16 = vpx_variance32x16_avx2;
+  vpx_variance32x32 = vpx_variance32x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance32x32 = vpx_variance32x32_avx2;
+  vpx_variance64x32 = vpx_variance64x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance64x32 = vpx_variance64x32_avx2;
+  vpx_variance64x64 = vpx_variance64x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance64x64 = vpx_variance64x64_avx2;
 }
 #endif
 

third_party/libvpx/source/config/mac/x64/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/mac/x64/vpx_scale_rtcd.h b/third_party/libvpx/source/config/mac/x64/vpx_scale_rtcd.h
index ada0f6d..0ba352cb 100644
--- a/third_party/libvpx/source/config/mac/x64/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/mac/x64/vpx_scale_rtcd.h
@@ -13,55 +13,81 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/nacl/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/nacl/vp8_rtcd.h b/third_party/libvpx/source/config/nacl/vp8_rtcd.h
index 650bd323..5af3874 100644
--- a/third_party/libvpx/source/config/nacl/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/nacl/vp8_rtcd.h
@@ -26,142 +26,312 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
 #define vp8_bilinear_predict16x16 vp8_bilinear_predict16x16_c
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict4x4 vp8_bilinear_predict4x4_c
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict8x4 vp8_bilinear_predict8x4_c
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_bilinear_predict8x8 vp8_bilinear_predict8x8_c
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
 #define vp8_block_error vp8_block_error_c
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
 #define vp8_copy_mem16x16 vp8_copy_mem16x16_c
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
 #define vp8_copy_mem8x4 vp8_copy_mem8x4_c
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
 #define vp8_copy_mem8x8 vp8_copy_mem8x8_c
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
 #define vp8_dc_only_idct_add vp8_dc_only_idct_add_c
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
 #define vp8_denoiser_filter vp8_denoiser_filter_c
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
 #define vp8_denoiser_filter_uv vp8_denoiser_filter_uv_c
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
 #define vp8_dequant_idct_add vp8_dequant_idct_add_c
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
 #define vp8_dequant_idct_add_uv_block vp8_dequant_idct_add_uv_block_c
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
 #define vp8_dequant_idct_add_y_block vp8_dequant_idct_add_y_block_c
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
 #define vp8_dequantize_b vp8_dequantize_b_c
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
 #define vp8_diamond_search_sad vp8_diamond_search_sad_c
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
 #define vp8_fast_quantize_b vp8_fast_quantize_b_c
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp8_filter_by_weight16x16 vp8_filter_by_weight16x16_c
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight8x8 vp8_filter_by_weight8x8_c
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
 #define vp8_full_search_sad vp8_full_search_sad_c
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
 #define vp8_loop_filter_bh vp8_loop_filter_bh_c
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
 #define vp8_loop_filter_bv vp8_loop_filter_bv_c
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbh vp8_loop_filter_mbh_c
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbv vp8_loop_filter_mbv_c
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
 #define vp8_loop_filter_simple_bh vp8_loop_filter_bhs_c
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
 #define vp8_loop_filter_simple_bv vp8_loop_filter_bvs_c
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbh vp8_loop_filter_simple_horizontal_edge_c
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbv vp8_loop_filter_simple_vertical_edge_c
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
 #define vp8_mbblock_error vp8_mbblock_error_c
 
-int vp8_mbuverror_c(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
 #define vp8_mbuverror vp8_mbuverror_c
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
 #define vp8_refining_search_sad vp8_refining_search_sad_c
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
 #define vp8_regular_quantize_b vp8_regular_quantize_b_c
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
 #define vp8_short_fdct4x4 vp8_short_fdct4x4_c
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
 #define vp8_short_fdct8x4 vp8_short_fdct8x4_c
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
 #define vp8_short_idct4x4llm vp8_short_idct4x4llm_c
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4 vp8_short_inv_walsh4x4_c
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
 #define vp8_short_walsh4x4 vp8_short_walsh4x4_c
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
 #define vp8_sixtap_predict16x16 vp8_sixtap_predict16x16_c
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict4x4 vp8_sixtap_predict4x4_c
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict8x4 vp8_sixtap_predict8x4_c
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
 #define vp8_sixtap_predict8x8 vp8_sixtap_predict8x8_c
 
 void vp8_rtcd(void);
@@ -169,9 +339,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/nacl/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/nacl/vp9_rtcd.h b/third_party/libvpx/source/config/nacl/vp9_rtcd.h
index a4a5510..ce78cca1 100644
--- a/third_party/libvpx/source/config/nacl/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/nacl/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,100 +30,258 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
 #define vp9_block_error vp9_block_error_c
 
-int64_t vp9_block_error_fp_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             int block_size);
 #define vp9_block_error_fp vp9_block_error_fp_c
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
 #define vp9_denoiser_filter vp9_denoiser_filter_c
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
 #define vp9_diamond_search_sad vp9_diamond_search_sad_c
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
 #define vp9_fdct8x8_quant vp9_fdct8x8_quant_c
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
 #define vp9_fht16x16 vp9_fht16x16_c
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht4x4 vp9_fht4x4_c
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
 #define vp9_fht8x8 vp9_fht8x8_c
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
 #define vp9_filter_by_weight16x16 vp9_filter_by_weight16x16_c
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp9_filter_by_weight8x8 vp9_filter_by_weight8x8_c
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_fwht4x4 vp9_fwht4x4_c
 
-int64_t vp9_highbd_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
+int64_t vp9_highbd_block_error_c(const tran_low_t* coeff,
+                                 const tran_low_t* dqcoeff,
+                                 intptr_t block_size,
+                                 int64_t* ssz,
+                                 int bd);
 #define vp9_highbd_block_error vp9_highbd_block_error_c
 
-void vp9_highbd_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht16x16_c(const int16_t* input,
+                           tran_low_t* output,
+                           int stride,
+                           int tx_type);
 #define vp9_highbd_fht16x16 vp9_highbd_fht16x16_c
 
-void vp9_highbd_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht4x4_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht4x4 vp9_highbd_fht4x4_c
 
-void vp9_highbd_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht8x8_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht8x8 vp9_highbd_fht8x8_c
 
-void vp9_highbd_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_highbd_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_highbd_fwht4x4 vp9_highbd_fwht4x4_c
 
-void vp9_highbd_iht16x16_256_add_c(const tran_low_t *input, uint16_t *output, int pitch, int tx_type, int bd);
+void vp9_highbd_iht16x16_256_add_c(const tran_low_t* input,
+                                   uint16_t* output,
+                                   int pitch,
+                                   int tx_type,
+                                   int bd);
 #define vp9_highbd_iht16x16_256_add vp9_highbd_iht16x16_256_add_c
 
-void vp9_highbd_iht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht4x4_16_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht4x4_16_add vp9_highbd_iht4x4_16_add_c
 
-void vp9_highbd_iht8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht8x8_64_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht8x8_64_add vp9_highbd_iht8x8_64_add_c
 
-void vp9_highbd_mbpost_proc_across_ip_c(uint16_t *src, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_across_ip_c(uint16_t* src,
+                                        int pitch,
+                                        int rows,
+                                        int cols,
+                                        int flimit);
 #define vp9_highbd_mbpost_proc_across_ip vp9_highbd_mbpost_proc_across_ip_c
 
-void vp9_highbd_mbpost_proc_down_c(uint16_t *dst, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_down_c(uint16_t* dst,
+                                   int pitch,
+                                   int rows,
+                                   int cols,
+                                   int flimit);
 #define vp9_highbd_mbpost_proc_down vp9_highbd_mbpost_proc_down_c
 
-void vp9_highbd_post_proc_down_and_across_c(const uint16_t *src_ptr, uint16_t *dst_ptr, int src_pixels_per_line, int dst_pixels_per_line, int rows, int cols, int flimit);
-#define vp9_highbd_post_proc_down_and_across vp9_highbd_post_proc_down_and_across_c
+void vp9_highbd_post_proc_down_and_across_c(const uint16_t* src_ptr,
+                                            uint16_t* dst_ptr,
+                                            int src_pixels_per_line,
+                                            int dst_pixels_per_line,
+                                            int rows,
+                                            int cols,
+                                            int flimit);
+#define vp9_highbd_post_proc_down_and_across \
+  vp9_highbd_post_proc_down_and_across_c
 
-void vp9_highbd_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_c(const tran_low_t* coeff_ptr,
+                              intptr_t n_coeffs,
+                              int skip_block,
+                              const int16_t* round_ptr,
+                              const int16_t* quant_ptr,
+                              tran_low_t* qcoeff_ptr,
+                              tran_low_t* dqcoeff_ptr,
+                              const int16_t* dequant_ptr,
+                              uint16_t* eob_ptr,
+                              const int16_t* scan,
+                              const int16_t* iscan);
 #define vp9_highbd_quantize_fp vp9_highbd_quantize_fp_c
 
-void vp9_highbd_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 #define vp9_highbd_quantize_fp_32x32 vp9_highbd_quantize_fp_32x32_c
 
-void vp9_highbd_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_highbd_temporal_filter_apply_c(const uint8_t* frame1,
+                                        unsigned int stride,
+                                        const uint8_t* frame2,
+                                        unsigned int block_width,
+                                        unsigned int block_height,
+                                        int strength,
+                                        int filter_weight,
+                                        uint32_t* accumulator,
+                                        uint16_t* count);
 #define vp9_highbd_temporal_filter_apply vp9_highbd_temporal_filter_apply_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
 #define vp9_iht16x16_256_add vp9_iht16x16_256_add_c
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
 #define vp9_iht4x4_16_add vp9_iht4x4_16_add_c
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
 #define vp9_iht8x8_64_add vp9_iht8x8_64_add_c
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
 #define vp9_quantize_fp vp9_quantize_fp_c
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vp9_quantize_fp_32x32 vp9_quantize_fp_32x32_c
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
 #define vp9_scale_and_extend_frame vp9_scale_and_extend_frame_c
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
 #define vp9_temporal_filter_apply vp9_temporal_filter_apply_c
 
 void vp9_rtcd(void);
@@ -131,9 +289,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/nacl/vpx_config.h

diff --git a/third_party/libvpx/source/config/nacl/vpx_config.h b/third_party/libvpx/source/config/nacl/vpx_config.h
index be4ac641..2c4574a 100644
--- a/third_party/libvpx/source/config/nacl/vpx_config.h
+++ b/third_party/libvpx/source/config/nacl/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 0
 #define HAVE_AVX2 0
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/nacl/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/nacl/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/nacl/vpx_dsp_rtcd.h
index e8379173f..114b01b 100644
--- a/third_party/libvpx/source/config/nacl/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/nacl/vpx_dsp_rtcd.h
@@ -14,1497 +14,3789 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
 #define vpx_avg_4x4 vpx_avg_4x4_c
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
 #define vpx_avg_8x8 vpx_avg_8x8_c
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
 #define vpx_comp_avg_pred vpx_comp_avg_pred_c
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_convolve8 vpx_convolve8_c
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_convolve8_avg vpx_convolve8_avg_c
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
 #define vpx_convolve8_avg_horiz vpx_convolve8_avg_horiz_c
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
 #define vpx_convolve8_avg_vert vpx_convolve8_avg_vert_c
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_convolve8_horiz vpx_convolve8_horiz_c
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
 #define vpx_convolve8_vert vpx_convolve8_vert_c
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_convolve_avg vpx_convolve_avg_c
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_convolve_copy vpx_convolve_copy_c
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_c
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_c
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_c
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_c
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_16x16 vpx_d153_predictor_16x16_c
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d153_predictor_32x32 vpx_d153_predictor_32x32_c
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_4x4 vpx_d153_predictor_4x4_c
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d153_predictor_8x8 vpx_d153_predictor_8x8_c
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_16x16 vpx_d207_predictor_16x16_c
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d207_predictor_32x32 vpx_d207_predictor_32x32_c
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_4x4 vpx_d207_predictor_4x4_c
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d207_predictor_8x8 vpx_d207_predictor_8x8_c
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d45_predictor_16x16 vpx_d45_predictor_16x16_c
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d45_predictor_32x32 vpx_d45_predictor_32x32_c
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d45_predictor_4x4 vpx_d45_predictor_4x4_c
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d45_predictor_8x8 vpx_d45_predictor_8x8_c
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_16x16 vpx_d63_predictor_16x16_c
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_d63_predictor_32x32 vpx_d63_predictor_32x32_c
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_4x4 vpx_d63_predictor_4x4_c
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_d63_predictor_8x8 vpx_d63_predictor_8x8_c
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_128_predictor_16x16 vpx_dc_128_predictor_16x16_c
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_128_predictor_32x32 vpx_dc_128_predictor_32x32_c
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_128_predictor_4x4 vpx_dc_128_predictor_4x4_c
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_128_predictor_8x8 vpx_dc_128_predictor_8x8_c
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_left_predictor_16x16 vpx_dc_left_predictor_16x16_c
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_left_predictor_32x32 vpx_dc_left_predictor_32x32_c
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_left_predictor_4x4 vpx_dc_left_predictor_4x4_c
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_left_predictor_8x8 vpx_dc_left_predictor_8x8_c
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_dc_predictor_16x16 vpx_dc_predictor_16x16_c
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_dc_predictor_32x32 vpx_dc_predictor_32x32_c
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_dc_predictor_4x4 vpx_dc_predictor_4x4_c
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_dc_predictor_8x8 vpx_dc_predictor_8x8_c
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_top_predictor_16x16 vpx_dc_top_predictor_16x16_c
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
 #define vpx_dc_top_predictor_32x32 vpx_dc_top_predictor_32x32_c
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_top_predictor_4x4 vpx_dc_top_predictor_4x4_c
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_dc_top_predictor_8x8 vpx_dc_top_predictor_8x8_c
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16 vpx_fdct16x16_c
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16_1 vpx_fdct16x16_1_c
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32 vpx_fdct32x32_c
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_1 vpx_fdct32x32_1_c
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_rd vpx_fdct32x32_rd_c
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4 vpx_fdct4x4_c
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4_1 vpx_fdct4x4_1_c
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8 vpx_fdct8x8_c
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8_1 vpx_fdct8x8_1_c
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
 #define vpx_get16x16var vpx_get16x16var_c
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_c
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
 #define vpx_get8x8var vpx_get8x8var_c
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
 #define vpx_get_mb_ss vpx_get_mb_ss_c
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_h_predictor_16x16 vpx_h_predictor_16x16_c
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_h_predictor_32x32 vpx_h_predictor_32x32_c
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_h_predictor_4x4 vpx_h_predictor_4x4_c
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_h_predictor_8x8 vpx_h_predictor_8x8_c
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          tran_low_t* coeff);
 #define vpx_hadamard_16x16 vpx_hadamard_16x16_c
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        tran_low_t* coeff);
 #define vpx_hadamard_8x8 vpx_hadamard_8x8_c
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_highbd_10_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_10_get16x16var vpx_highbd_10_get16x16var_c
 
-void vpx_highbd_10_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_10_get8x8var vpx_highbd_10_get8x8var_c
 
-unsigned int vpx_highbd_10_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
 #define vpx_highbd_10_mse16x16 vpx_highbd_10_mse16x16_c
 
-unsigned int vpx_highbd_10_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse16x8 vpx_highbd_10_mse16x8_c
 
-unsigned int vpx_highbd_10_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse8x16 vpx_highbd_10_mse8x16_c
 
-unsigned int vpx_highbd_10_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_10_mse8x8 vpx_highbd_10_mse8x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x16 vpx_highbd_10_sub_pixel_avg_variance16x16_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x16 \
+  vpx_highbd_10_sub_pixel_avg_variance16x16_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x32 vpx_highbd_10_sub_pixel_avg_variance16x32_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x32 \
+  vpx_highbd_10_sub_pixel_avg_variance16x32_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x8 vpx_highbd_10_sub_pixel_avg_variance16x8_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x8 \
+  vpx_highbd_10_sub_pixel_avg_variance16x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x16 vpx_highbd_10_sub_pixel_avg_variance32x16_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x16 \
+  vpx_highbd_10_sub_pixel_avg_variance32x16_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x32 vpx_highbd_10_sub_pixel_avg_variance32x32_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x32 \
+  vpx_highbd_10_sub_pixel_avg_variance32x32_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x64 vpx_highbd_10_sub_pixel_avg_variance32x64_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x64 \
+  vpx_highbd_10_sub_pixel_avg_variance32x64_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x4 vpx_highbd_10_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x4 \
+  vpx_highbd_10_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x8 vpx_highbd_10_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x8 \
+  vpx_highbd_10_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance64x32 vpx_highbd_10_sub_pixel_avg_variance64x32_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance64x32 \
+  vpx_highbd_10_sub_pixel_avg_variance64x32_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance64x64 vpx_highbd_10_sub_pixel_avg_variance64x64_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance64x64 \
+  vpx_highbd_10_sub_pixel_avg_variance64x64_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x16 vpx_highbd_10_sub_pixel_avg_variance8x16_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x16 \
+  vpx_highbd_10_sub_pixel_avg_variance8x16_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x4 vpx_highbd_10_sub_pixel_avg_variance8x4_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x4 \
+  vpx_highbd_10_sub_pixel_avg_variance8x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x8 vpx_highbd_10_sub_pixel_avg_variance8x8_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x8 \
+  vpx_highbd_10_sub_pixel_avg_variance8x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x16 vpx_highbd_10_sub_pixel_variance16x16_c
+uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x16 \
+  vpx_highbd_10_sub_pixel_variance16x16_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x32 vpx_highbd_10_sub_pixel_variance16x32_c
+uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x32 \
+  vpx_highbd_10_sub_pixel_variance16x32_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x8 vpx_highbd_10_sub_pixel_variance16x8_c
+uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x8 \
+  vpx_highbd_10_sub_pixel_variance16x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x16 vpx_highbd_10_sub_pixel_variance32x16_c
+uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x16 \
+  vpx_highbd_10_sub_pixel_variance32x16_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x32 vpx_highbd_10_sub_pixel_variance32x32_c
+uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x32 \
+  vpx_highbd_10_sub_pixel_variance32x32_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x64 vpx_highbd_10_sub_pixel_variance32x64_c
+uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x64 \
+  vpx_highbd_10_sub_pixel_variance32x64_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x4 vpx_highbd_10_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x4 \
+  vpx_highbd_10_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x8 vpx_highbd_10_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x8 \
+  vpx_highbd_10_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance64x32 vpx_highbd_10_sub_pixel_variance64x32_c
+uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance64x32 \
+  vpx_highbd_10_sub_pixel_variance64x32_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance64x64 vpx_highbd_10_sub_pixel_variance64x64_c
+uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance64x64 \
+  vpx_highbd_10_sub_pixel_variance64x64_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x16 vpx_highbd_10_sub_pixel_variance8x16_c
+uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x16 \
+  vpx_highbd_10_sub_pixel_variance8x16_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x4 vpx_highbd_10_sub_pixel_variance8x4_c
+uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x4 \
+  vpx_highbd_10_sub_pixel_variance8x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x8 vpx_highbd_10_sub_pixel_variance8x8_c
+uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x8 \
+  vpx_highbd_10_sub_pixel_variance8x8_c
 
-unsigned int vpx_highbd_10_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_10_variance16x16 vpx_highbd_10_variance16x16_c
 
-unsigned int vpx_highbd_10_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_10_variance16x32 vpx_highbd_10_variance16x32_c
 
-unsigned int vpx_highbd_10_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_10_variance16x8 vpx_highbd_10_variance16x8_c
 
-unsigned int vpx_highbd_10_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_10_variance32x16 vpx_highbd_10_variance32x16_c
 
-unsigned int vpx_highbd_10_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_10_variance32x32 vpx_highbd_10_variance32x32_c
 
-unsigned int vpx_highbd_10_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_10_variance32x64 vpx_highbd_10_variance32x64_c
 
-unsigned int vpx_highbd_10_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x4 vpx_highbd_10_variance4x4_c
 
-unsigned int vpx_highbd_10_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x8 vpx_highbd_10_variance4x8_c
 
-unsigned int vpx_highbd_10_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_10_variance64x32 vpx_highbd_10_variance64x32_c
 
-unsigned int vpx_highbd_10_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_10_variance64x64 vpx_highbd_10_variance64x64_c
 
-unsigned int vpx_highbd_10_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_10_variance8x16 vpx_highbd_10_variance8x16_c
 
-unsigned int vpx_highbd_10_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance8x4 vpx_highbd_10_variance8x4_c
 
-unsigned int vpx_highbd_10_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance8x8 vpx_highbd_10_variance8x8_c
 
-void vpx_highbd_12_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_12_get16x16var vpx_highbd_12_get16x16var_c
 
-void vpx_highbd_12_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_12_get8x8var vpx_highbd_12_get8x8var_c
 
-unsigned int vpx_highbd_12_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
 #define vpx_highbd_12_mse16x16 vpx_highbd_12_mse16x16_c
 
-unsigned int vpx_highbd_12_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse16x8 vpx_highbd_12_mse16x8_c
 
-unsigned int vpx_highbd_12_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse8x16 vpx_highbd_12_mse8x16_c
 
-unsigned int vpx_highbd_12_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_12_mse8x8 vpx_highbd_12_mse8x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x16 vpx_highbd_12_sub_pixel_avg_variance16x16_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x16 \
+  vpx_highbd_12_sub_pixel_avg_variance16x16_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x32 vpx_highbd_12_sub_pixel_avg_variance16x32_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x32 \
+  vpx_highbd_12_sub_pixel_avg_variance16x32_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x8 vpx_highbd_12_sub_pixel_avg_variance16x8_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x8 \
+  vpx_highbd_12_sub_pixel_avg_variance16x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x16 vpx_highbd_12_sub_pixel_avg_variance32x16_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x16 \
+  vpx_highbd_12_sub_pixel_avg_variance32x16_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x32 vpx_highbd_12_sub_pixel_avg_variance32x32_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x32 \
+  vpx_highbd_12_sub_pixel_avg_variance32x32_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x64 vpx_highbd_12_sub_pixel_avg_variance32x64_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x64 \
+  vpx_highbd_12_sub_pixel_avg_variance32x64_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x4 vpx_highbd_12_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x4 \
+  vpx_highbd_12_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x8 vpx_highbd_12_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x8 \
+  vpx_highbd_12_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance64x32 vpx_highbd_12_sub_pixel_avg_variance64x32_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance64x32 \
+  vpx_highbd_12_sub_pixel_avg_variance64x32_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance64x64 vpx_highbd_12_sub_pixel_avg_variance64x64_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance64x64 \
+  vpx_highbd_12_sub_pixel_avg_variance64x64_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x16 vpx_highbd_12_sub_pixel_avg_variance8x16_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x16 \
+  vpx_highbd_12_sub_pixel_avg_variance8x16_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x4 vpx_highbd_12_sub_pixel_avg_variance8x4_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x4 \
+  vpx_highbd_12_sub_pixel_avg_variance8x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x8 vpx_highbd_12_sub_pixel_avg_variance8x8_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x8 \
+  vpx_highbd_12_sub_pixel_avg_variance8x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x16 vpx_highbd_12_sub_pixel_variance16x16_c
+uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x16 \
+  vpx_highbd_12_sub_pixel_variance16x16_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x32 vpx_highbd_12_sub_pixel_variance16x32_c
+uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x32 \
+  vpx_highbd_12_sub_pixel_variance16x32_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x8 vpx_highbd_12_sub_pixel_variance16x8_c
+uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x8 \
+  vpx_highbd_12_sub_pixel_variance16x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x16 vpx_highbd_12_sub_pixel_variance32x16_c
+uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x16 \
+  vpx_highbd_12_sub_pixel_variance32x16_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x32 vpx_highbd_12_sub_pixel_variance32x32_c
+uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x32 \
+  vpx_highbd_12_sub_pixel_variance32x32_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x64 vpx_highbd_12_sub_pixel_variance32x64_c
+uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x64 \
+  vpx_highbd_12_sub_pixel_variance32x64_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x4 vpx_highbd_12_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x4 \
+  vpx_highbd_12_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x8 vpx_highbd_12_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x8 \
+  vpx_highbd_12_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance64x32 vpx_highbd_12_sub_pixel_variance64x32_c
+uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance64x32 \
+  vpx_highbd_12_sub_pixel_variance64x32_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance64x64 vpx_highbd_12_sub_pixel_variance64x64_c
+uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance64x64 \
+  vpx_highbd_12_sub_pixel_variance64x64_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x16 vpx_highbd_12_sub_pixel_variance8x16_c
+uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x16 \
+  vpx_highbd_12_sub_pixel_variance8x16_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x4 vpx_highbd_12_sub_pixel_variance8x4_c
+uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x4 \
+  vpx_highbd_12_sub_pixel_variance8x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x8 vpx_highbd_12_sub_pixel_variance8x8_c
+uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x8 \
+  vpx_highbd_12_sub_pixel_variance8x8_c
 
-unsigned int vpx_highbd_12_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_12_variance16x16 vpx_highbd_12_variance16x16_c
 
-unsigned int vpx_highbd_12_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_12_variance16x32 vpx_highbd_12_variance16x32_c
 
-unsigned int vpx_highbd_12_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_12_variance16x8 vpx_highbd_12_variance16x8_c
 
-unsigned int vpx_highbd_12_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_12_variance32x16 vpx_highbd_12_variance32x16_c
 
-unsigned int vpx_highbd_12_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_12_variance32x32 vpx_highbd_12_variance32x32_c
 
-unsigned int vpx_highbd_12_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_12_variance32x64 vpx_highbd_12_variance32x64_c
 
-unsigned int vpx_highbd_12_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x4 vpx_highbd_12_variance4x4_c
 
-unsigned int vpx_highbd_12_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x8 vpx_highbd_12_variance4x8_c
 
-unsigned int vpx_highbd_12_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_12_variance64x32 vpx_highbd_12_variance64x32_c
 
-unsigned int vpx_highbd_12_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_12_variance64x64 vpx_highbd_12_variance64x64_c
 
-unsigned int vpx_highbd_12_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_12_variance8x16 vpx_highbd_12_variance8x16_c
 
-unsigned int vpx_highbd_12_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance8x4 vpx_highbd_12_variance8x4_c
 
-unsigned int vpx_highbd_12_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance8x8 vpx_highbd_12_variance8x8_c
 
-void vpx_highbd_8_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get16x16var_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse,
+                                int* sum);
 #define vpx_highbd_8_get16x16var vpx_highbd_8_get16x16var_c
 
-void vpx_highbd_8_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get8x8var_c(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              unsigned int* sse,
+                              int* sum);
 #define vpx_highbd_8_get8x8var vpx_highbd_8_get8x8var_c
 
-unsigned int vpx_highbd_8_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_8_mse16x16 vpx_highbd_8_mse16x16_c
 
-unsigned int vpx_highbd_8_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse16x8 vpx_highbd_8_mse16x8_c
 
-unsigned int vpx_highbd_8_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x16_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse8x16 vpx_highbd_8_mse8x16_c
 
-unsigned int vpx_highbd_8_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x8_c(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int recon_stride,
+                                   unsigned int* sse);
 #define vpx_highbd_8_mse8x8 vpx_highbd_8_mse8x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x16 vpx_highbd_8_sub_pixel_avg_variance16x16_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x16 \
+  vpx_highbd_8_sub_pixel_avg_variance16x16_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x32 vpx_highbd_8_sub_pixel_avg_variance16x32_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x32 \
+  vpx_highbd_8_sub_pixel_avg_variance16x32_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x8 vpx_highbd_8_sub_pixel_avg_variance16x8_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x8 \
+  vpx_highbd_8_sub_pixel_avg_variance16x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x16 vpx_highbd_8_sub_pixel_avg_variance32x16_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x16 \
+  vpx_highbd_8_sub_pixel_avg_variance32x16_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x32 vpx_highbd_8_sub_pixel_avg_variance32x32_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x32 \
+  vpx_highbd_8_sub_pixel_avg_variance32x32_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x64 vpx_highbd_8_sub_pixel_avg_variance32x64_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x64 \
+  vpx_highbd_8_sub_pixel_avg_variance32x64_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x4 vpx_highbd_8_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x4 \
+  vpx_highbd_8_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x8 vpx_highbd_8_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x8 \
+  vpx_highbd_8_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance64x32 vpx_highbd_8_sub_pixel_avg_variance64x32_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance64x32 \
+  vpx_highbd_8_sub_pixel_avg_variance64x32_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance64x64 vpx_highbd_8_sub_pixel_avg_variance64x64_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance64x64 \
+  vpx_highbd_8_sub_pixel_avg_variance64x64_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x16 vpx_highbd_8_sub_pixel_avg_variance8x16_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x16 \
+  vpx_highbd_8_sub_pixel_avg_variance8x16_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x4 vpx_highbd_8_sub_pixel_avg_variance8x4_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x4 \
+  vpx_highbd_8_sub_pixel_avg_variance8x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x8 vpx_highbd_8_sub_pixel_avg_variance8x8_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x8 \
+  vpx_highbd_8_sub_pixel_avg_variance8x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x16 vpx_highbd_8_sub_pixel_variance16x16_c
+uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x16 \
+  vpx_highbd_8_sub_pixel_variance16x16_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x32 vpx_highbd_8_sub_pixel_variance16x32_c
+uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x32 \
+  vpx_highbd_8_sub_pixel_variance16x32_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x8 vpx_highbd_8_sub_pixel_variance16x8_c
+uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x8 \
+  vpx_highbd_8_sub_pixel_variance16x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x16 vpx_highbd_8_sub_pixel_variance32x16_c
+uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x16 \
+  vpx_highbd_8_sub_pixel_variance32x16_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x32 vpx_highbd_8_sub_pixel_variance32x32_c
+uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x32 \
+  vpx_highbd_8_sub_pixel_variance32x32_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x64 vpx_highbd_8_sub_pixel_variance32x64_c
+uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x64 \
+  vpx_highbd_8_sub_pixel_variance32x64_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x4 vpx_highbd_8_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x8 vpx_highbd_8_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance64x32 vpx_highbd_8_sub_pixel_variance64x32_c
+uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance64x32 \
+  vpx_highbd_8_sub_pixel_variance64x32_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance64x64 vpx_highbd_8_sub_pixel_variance64x64_c
+uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance64x64 \
+  vpx_highbd_8_sub_pixel_variance64x64_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance8x16 vpx_highbd_8_sub_pixel_variance8x16_c
+uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance8x16 \
+  vpx_highbd_8_sub_pixel_variance8x16_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance8x4 vpx_highbd_8_sub_pixel_variance8x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance8x8 vpx_highbd_8_sub_pixel_variance8x8_c
 
-unsigned int vpx_highbd_8_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_8_variance16x16 vpx_highbd_8_variance16x16_c
 
-unsigned int vpx_highbd_8_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_8_variance16x32 vpx_highbd_8_variance16x32_c
 
-unsigned int vpx_highbd_8_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_8_variance16x8 vpx_highbd_8_variance16x8_c
 
-unsigned int vpx_highbd_8_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_8_variance32x16 vpx_highbd_8_variance32x16_c
 
-unsigned int vpx_highbd_8_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_8_variance32x32 vpx_highbd_8_variance32x32_c
 
-unsigned int vpx_highbd_8_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_8_variance32x64 vpx_highbd_8_variance32x64_c
 
-unsigned int vpx_highbd_8_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x4 vpx_highbd_8_variance4x4_c
 
-unsigned int vpx_highbd_8_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x8 vpx_highbd_8_variance4x8_c
 
-unsigned int vpx_highbd_8_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_8_variance64x32 vpx_highbd_8_variance64x32_c
 
-unsigned int vpx_highbd_8_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
 #define vpx_highbd_8_variance64x64 vpx_highbd_8_variance64x64_c
 
-unsigned int vpx_highbd_8_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x16_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_8_variance8x16 vpx_highbd_8_variance8x16_c
 
-unsigned int vpx_highbd_8_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance8x4 vpx_highbd_8_variance8x4_c
 
-unsigned int vpx_highbd_8_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance8x8 vpx_highbd_8_variance8x8_c
 
-unsigned int vpx_highbd_avg_4x4_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_4x4_c(const uint8_t*, int p);
 #define vpx_highbd_avg_4x4 vpx_highbd_avg_4x4_c
 
-unsigned int vpx_highbd_avg_8x8_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_8x8_c(const uint8_t*, int p);
 #define vpx_highbd_avg_8x8 vpx_highbd_avg_8x8_c
 
-void vpx_highbd_comp_avg_pred_c(uint16_t *comp_pred, const uint8_t *pred8, int width, int height, const uint8_t *ref8, int ref_stride);
+void vpx_highbd_comp_avg_pred_c(uint16_t* comp_pred,
+                                const uint8_t* pred8,
+                                int width,
+                                int height,
+                                const uint8_t* ref8,
+                                int ref_stride);
 #define vpx_highbd_comp_avg_pred vpx_highbd_comp_avg_pred_c
 
-void vpx_highbd_convolve8_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_c(const uint16_t* src,
+                            ptrdiff_t src_stride,
+                            uint16_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h,
+                            int bps);
 #define vpx_highbd_convolve8 vpx_highbd_convolve8_c
 
-void vpx_highbd_convolve8_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
 #define vpx_highbd_convolve8_avg vpx_highbd_convolve8_avg_c
 
-void vpx_highbd_convolve8_avg_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_horiz_c(const uint16_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint16_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h,
+                                      int bps);
 #define vpx_highbd_convolve8_avg_horiz vpx_highbd_convolve8_avg_horiz_c
 
-void vpx_highbd_convolve8_avg_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_vert_c(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
 #define vpx_highbd_convolve8_avg_vert vpx_highbd_convolve8_avg_vert_c
 
-void vpx_highbd_convolve8_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_horiz_c(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
 #define vpx_highbd_convolve8_horiz vpx_highbd_convolve8_horiz_c
 
-void vpx_highbd_convolve8_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_vert_c(const uint16_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint16_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h,
+                                 int bps);
 #define vpx_highbd_convolve8_vert vpx_highbd_convolve8_vert_c
 
-void vpx_highbd_convolve_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_avg_c(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
 #define vpx_highbd_convolve_avg vpx_highbd_convolve_avg_c
 
-void vpx_highbd_convolve_copy_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_copy_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
 #define vpx_highbd_convolve_copy vpx_highbd_convolve_copy_c
 
-void vpx_highbd_d117_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_16x16 vpx_highbd_d117_predictor_16x16_c
 
-void vpx_highbd_d117_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_32x32 vpx_highbd_d117_predictor_32x32_c
 
-void vpx_highbd_d117_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_4x4 vpx_highbd_d117_predictor_4x4_c
 
-void vpx_highbd_d117_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_8x8 vpx_highbd_d117_predictor_8x8_c
 
-void vpx_highbd_d135_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_16x16 vpx_highbd_d135_predictor_16x16_c
 
-void vpx_highbd_d135_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_32x32 vpx_highbd_d135_predictor_32x32_c
 
-void vpx_highbd_d135_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_4x4 vpx_highbd_d135_predictor_4x4_c
 
-void vpx_highbd_d135_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_8x8 vpx_highbd_d135_predictor_8x8_c
 
-void vpx_highbd_d153_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_16x16 vpx_highbd_d153_predictor_16x16_c
 
-void vpx_highbd_d153_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_32x32 vpx_highbd_d153_predictor_32x32_c
 
-void vpx_highbd_d153_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_4x4 vpx_highbd_d153_predictor_4x4_c
 
-void vpx_highbd_d153_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_8x8 vpx_highbd_d153_predictor_8x8_c
 
-void vpx_highbd_d207_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_16x16 vpx_highbd_d207_predictor_16x16_c
 
-void vpx_highbd_d207_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_32x32 vpx_highbd_d207_predictor_32x32_c
 
-void vpx_highbd_d207_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_4x4 vpx_highbd_d207_predictor_4x4_c
 
-void vpx_highbd_d207_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_8x8 vpx_highbd_d207_predictor_8x8_c
 
-void vpx_highbd_d45_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_16x16 vpx_highbd_d45_predictor_16x16_c
 
-void vpx_highbd_d45_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_32x32 vpx_highbd_d45_predictor_32x32_c
 
-void vpx_highbd_d45_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_4x4 vpx_highbd_d45_predictor_4x4_c
 
-void vpx_highbd_d45_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_8x8 vpx_highbd_d45_predictor_8x8_c
 
-void vpx_highbd_d63_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_16x16 vpx_highbd_d63_predictor_16x16_c
 
-void vpx_highbd_d63_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_32x32 vpx_highbd_d63_predictor_32x32_c
 
-void vpx_highbd_d63_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_4x4 vpx_highbd_d63_predictor_4x4_c
 
-void vpx_highbd_d63_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_8x8 vpx_highbd_d63_predictor_8x8_c
 
-void vpx_highbd_dc_128_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_16x16 vpx_highbd_dc_128_predictor_16x16_c
 
-void vpx_highbd_dc_128_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_32x32 vpx_highbd_dc_128_predictor_32x32_c
 
-void vpx_highbd_dc_128_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_4x4 vpx_highbd_dc_128_predictor_4x4_c
 
-void vpx_highbd_dc_128_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_8x8 vpx_highbd_dc_128_predictor_8x8_c
 
-void vpx_highbd_dc_left_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_16x16_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_16x16 vpx_highbd_dc_left_predictor_16x16_c
 
-void vpx_highbd_dc_left_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_32x32_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_32x32 vpx_highbd_dc_left_predictor_32x32_c
 
-void vpx_highbd_dc_left_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_4x4_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_4x4 vpx_highbd_dc_left_predictor_4x4_c
 
-void vpx_highbd_dc_left_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_8x8_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_8x8 vpx_highbd_dc_left_predictor_8x8_c
 
-void vpx_highbd_dc_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_dc_predictor_16x16 vpx_highbd_dc_predictor_16x16_c
 
-void vpx_highbd_dc_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_dc_predictor_32x32 vpx_highbd_dc_predictor_32x32_c
 
-void vpx_highbd_dc_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
 #define vpx_highbd_dc_predictor_4x4 vpx_highbd_dc_predictor_4x4_c
 
-void vpx_highbd_dc_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
 #define vpx_highbd_dc_predictor_8x8 vpx_highbd_dc_predictor_8x8_c
 
-void vpx_highbd_dc_top_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_16x16 vpx_highbd_dc_top_predictor_16x16_c
 
-void vpx_highbd_dc_top_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_32x32 vpx_highbd_dc_top_predictor_32x32_c
 
-void vpx_highbd_dc_top_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_4x4 vpx_highbd_dc_top_predictor_4x4_c
 
-void vpx_highbd_dc_top_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_8x8 vpx_highbd_dc_top_predictor_8x8_c
 
-void vpx_highbd_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
 #define vpx_highbd_fdct16x16 vpx_highbd_fdct16x16_c
 
-void vpx_highbd_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct16x16_1 vpx_highbd_fdct16x16_1_c
 
-void vpx_highbd_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
 #define vpx_highbd_fdct32x32 vpx_highbd_fdct32x32_c
 
-void vpx_highbd_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct32x32_1 vpx_highbd_fdct32x32_1_c
 
-void vpx_highbd_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_rd_c(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
 #define vpx_highbd_fdct32x32_rd vpx_highbd_fdct32x32_rd_c
 
-void vpx_highbd_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_highbd_fdct4x4 vpx_highbd_fdct4x4_c
 
-void vpx_highbd_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_highbd_fdct8x8 vpx_highbd_fdct8x8_c
 
-void vpx_highbd_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_1_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
 #define vpx_highbd_fdct8x8_1 vpx_highbd_fdct8x8_1_c
 
-void vpx_highbd_h_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_16x16 vpx_highbd_h_predictor_16x16_c
 
-void vpx_highbd_h_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_32x32 vpx_highbd_h_predictor_32x32_c
 
-void vpx_highbd_h_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_4x4 vpx_highbd_h_predictor_4x4_c
 
-void vpx_highbd_h_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_8x8 vpx_highbd_h_predictor_8x8_c
 
-void vpx_highbd_idct16x16_10_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_10_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct16x16_10_add vpx_highbd_idct16x16_10_add_c
 
-void vpx_highbd_idct16x16_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
 #define vpx_highbd_idct16x16_1_add vpx_highbd_idct16x16_1_add_c
 
-void vpx_highbd_idct16x16_256_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_256_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
 #define vpx_highbd_idct16x16_256_add vpx_highbd_idct16x16_256_add_c
 
-void vpx_highbd_idct16x16_38_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_38_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct16x16_38_add vpx_highbd_idct16x16_38_add_c
 
-void vpx_highbd_idct32x32_1024_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1024_add_c(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
 #define vpx_highbd_idct32x32_1024_add vpx_highbd_idct32x32_1024_add_c
 
-void vpx_highbd_idct32x32_135_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_135_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
 #define vpx_highbd_idct32x32_135_add vpx_highbd_idct32x32_135_add_c
 
-void vpx_highbd_idct32x32_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
 #define vpx_highbd_idct32x32_1_add vpx_highbd_idct32x32_1_add_c
 
-void vpx_highbd_idct32x32_34_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_34_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct32x32_34_add vpx_highbd_idct32x32_34_add_c
 
-void vpx_highbd_idct4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
 #define vpx_highbd_idct4x4_16_add vpx_highbd_idct4x4_16_add_c
 
-void vpx_highbd_idct4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
 #define vpx_highbd_idct4x4_1_add vpx_highbd_idct4x4_1_add_c
 
-void vpx_highbd_idct8x8_12_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_12_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
 #define vpx_highbd_idct8x8_12_add vpx_highbd_idct8x8_12_add_c
 
-void vpx_highbd_idct8x8_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
 #define vpx_highbd_idct8x8_1_add vpx_highbd_idct8x8_1_add_c
 
-void vpx_highbd_idct8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_64_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
 #define vpx_highbd_idct8x8_64_add vpx_highbd_idct8x8_64_add_c
 
-void vpx_highbd_iwht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
 #define vpx_highbd_iwht4x4_16_add vpx_highbd_iwht4x4_16_add_c
 
-void vpx_highbd_iwht4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
 #define vpx_highbd_iwht4x4_1_add vpx_highbd_iwht4x4_1_add_c
 
-void vpx_highbd_lpf_horizontal_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_c(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
 #define vpx_highbd_lpf_horizontal_16 vpx_highbd_lpf_horizontal_16_c
 
-void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh,
+                                         int bd);
 #define vpx_highbd_lpf_horizontal_16_dual vpx_highbd_lpf_horizontal_16_dual_c
 
-void vpx_highbd_lpf_horizontal_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_4_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
 #define vpx_highbd_lpf_horizontal_4 vpx_highbd_lpf_horizontal_4_c
 
-void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
 #define vpx_highbd_lpf_horizontal_4_dual vpx_highbd_lpf_horizontal_4_dual_c
 
-void vpx_highbd_lpf_horizontal_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_8_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
 #define vpx_highbd_lpf_horizontal_8 vpx_highbd_lpf_horizontal_8_c
 
-void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
 #define vpx_highbd_lpf_horizontal_8_dual vpx_highbd_lpf_horizontal_8_dual_c
 
-void vpx_highbd_lpf_vertical_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_c(uint16_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh,
+                                  int bd);
 #define vpx_highbd_lpf_vertical_16 vpx_highbd_lpf_vertical_16_c
 
-void vpx_highbd_lpf_vertical_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_dual_c(uint16_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh,
+                                       int bd);
 #define vpx_highbd_lpf_vertical_16_dual vpx_highbd_lpf_vertical_16_dual_c
 
-void vpx_highbd_lpf_vertical_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_4_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
 #define vpx_highbd_lpf_vertical_4 vpx_highbd_lpf_vertical_4_c
 
-void vpx_highbd_lpf_vertical_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_4_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
 #define vpx_highbd_lpf_vertical_4_dual vpx_highbd_lpf_vertical_4_dual_c
 
-void vpx_highbd_lpf_vertical_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_8_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
 #define vpx_highbd_lpf_vertical_8 vpx_highbd_lpf_vertical_8_c
 
-void vpx_highbd_lpf_vertical_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_8_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
 #define vpx_highbd_lpf_vertical_8_dual vpx_highbd_lpf_vertical_8_dual_c
 
-void vpx_highbd_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_highbd_minmax_8x8_c(const uint8_t* s,
+                             int p,
+                             const uint8_t* d,
+                             int dp,
+                             int* min,
+                             int* max);
 #define vpx_highbd_minmax_8x8 vpx_highbd_minmax_8x8_c
 
-void vpx_highbd_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* zbin_ptr,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             const int16_t* quant_shift_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vpx_highbd_quantize_b vpx_highbd_quantize_b_c
 
-void vpx_highbd_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
 #define vpx_highbd_quantize_b_32x32 vpx_highbd_quantize_b_32x32_c
 
-unsigned int vpx_highbd_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
 #define vpx_highbd_sad16x16 vpx_highbd_sad16x16_c
 
-unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
 #define vpx_highbd_sad16x16_avg vpx_highbd_sad16x16_avg_c
 
-void vpx_highbd_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
 #define vpx_highbd_sad16x16x4d vpx_highbd_sad16x16x4d_c
 
-unsigned int vpx_highbd_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
 #define vpx_highbd_sad16x32 vpx_highbd_sad16x32_c
 
-unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
 #define vpx_highbd_sad16x32_avg vpx_highbd_sad16x32_avg_c
 
-void vpx_highbd_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
 #define vpx_highbd_sad16x32x4d vpx_highbd_sad16x32x4d_c
 
-unsigned int vpx_highbd_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x8_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
 #define vpx_highbd_sad16x8 vpx_highbd_sad16x8_c
 
-unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
 #define vpx_highbd_sad16x8_avg vpx_highbd_sad16x8_avg_c
 
-void vpx_highbd_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x8x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
 #define vpx_highbd_sad16x8x4d vpx_highbd_sad16x8x4d_c
 
-unsigned int vpx_highbd_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
 #define vpx_highbd_sad32x16 vpx_highbd_sad32x16_c
 
-unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
 #define vpx_highbd_sad32x16_avg vpx_highbd_sad32x16_avg_c
 
-void vpx_highbd_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
 #define vpx_highbd_sad32x16x4d vpx_highbd_sad32x16x4d_c
 
-unsigned int vpx_highbd_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
 #define vpx_highbd_sad32x32 vpx_highbd_sad32x32_c
 
-unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
 #define vpx_highbd_sad32x32_avg vpx_highbd_sad32x32_avg_c
 
-void vpx_highbd_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
 #define vpx_highbd_sad32x32x4d vpx_highbd_sad32x32x4d_c
 
-unsigned int vpx_highbd_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
 #define vpx_highbd_sad32x64 vpx_highbd_sad32x64_c
 
-unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
 #define vpx_highbd_sad32x64_avg vpx_highbd_sad32x64_avg_c
 
-void vpx_highbd_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
 #define vpx_highbd_sad32x64x4d vpx_highbd_sad32x64x4d_c
 
-unsigned int vpx_highbd_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x4 vpx_highbd_sad4x4_c
 
-unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x4_avg vpx_highbd_sad4x4_avg_c
 
-void vpx_highbd_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
 #define vpx_highbd_sad4x4x4d vpx_highbd_sad4x4x4d_c
 
-unsigned int vpx_highbd_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x8 vpx_highbd_sad4x8_c
 
-unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x8_avg vpx_highbd_sad4x8_avg_c
 
-void vpx_highbd_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
 #define vpx_highbd_sad4x8x4d vpx_highbd_sad4x8x4d_c
 
-unsigned int vpx_highbd_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
 #define vpx_highbd_sad64x32 vpx_highbd_sad64x32_c
 
-unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
 #define vpx_highbd_sad64x32_avg vpx_highbd_sad64x32_avg_c
 
-void vpx_highbd_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
 #define vpx_highbd_sad64x32x4d vpx_highbd_sad64x32x4d_c
 
-unsigned int vpx_highbd_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
 #define vpx_highbd_sad64x64 vpx_highbd_sad64x64_c
 
-unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
 #define vpx_highbd_sad64x64_avg vpx_highbd_sad64x64_avg_c
 
-void vpx_highbd_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
 #define vpx_highbd_sad64x64x4d vpx_highbd_sad64x64x4d_c
 
-unsigned int vpx_highbd_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
 #define vpx_highbd_sad8x16 vpx_highbd_sad8x16_c
 
-unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
 #define vpx_highbd_sad8x16_avg vpx_highbd_sad8x16_avg_c
 
-void vpx_highbd_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
 #define vpx_highbd_sad8x16x4d vpx_highbd_sad8x16x4d_c
 
-unsigned int vpx_highbd_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad8x4 vpx_highbd_sad8x4_c
 
-unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad8x4_avg vpx_highbd_sad8x4_avg_c
 
-void vpx_highbd_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
 #define vpx_highbd_sad8x4x4d vpx_highbd_sad8x4x4d_c
 
-unsigned int vpx_highbd_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad8x8 vpx_highbd_sad8x8_c
 
-unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad8x8_avg vpx_highbd_sad8x8_avg_c
 
-void vpx_highbd_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
 #define vpx_highbd_sad8x8x4d vpx_highbd_sad8x8x4d_c
 
-void vpx_highbd_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride, int bd);
+void vpx_highbd_subtract_block_c(int rows,
+                                 int cols,
+                                 int16_t* diff_ptr,
+                                 ptrdiff_t diff_stride,
+                                 const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 const uint8_t* pred_ptr,
+                                 ptrdiff_t pred_stride,
+                                 int bd);
 #define vpx_highbd_subtract_block vpx_highbd_subtract_block_c
 
-void vpx_highbd_tm_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_tm_predictor_16x16 vpx_highbd_tm_predictor_16x16_c
 
-void vpx_highbd_tm_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_tm_predictor_32x32 vpx_highbd_tm_predictor_32x32_c
 
-void vpx_highbd_tm_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
 #define vpx_highbd_tm_predictor_4x4 vpx_highbd_tm_predictor_4x4_c
 
-void vpx_highbd_tm_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
 #define vpx_highbd_tm_predictor_8x8 vpx_highbd_tm_predictor_8x8_c
 
-void vpx_highbd_v_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_v_predictor_16x16 vpx_highbd_v_predictor_16x16_c
 
-void vpx_highbd_v_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_v_predictor_32x32 vpx_highbd_v_predictor_32x32_c
 
-void vpx_highbd_v_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_v_predictor_4x4 vpx_highbd_v_predictor_4x4_c
 
-void vpx_highbd_v_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_v_predictor_8x8 vpx_highbd_v_predictor_8x8_c
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_10_add vpx_idct16x16_10_add_c
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_1_add vpx_idct16x16_1_add_c
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct16x16_256_add vpx_idct16x16_256_add_c
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct16x16_38_add vpx_idct16x16_38_add_c
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct32x32_1024_add vpx_idct32x32_1024_add_c
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct32x32_135_add vpx_idct32x32_135_add_c
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct32x32_1_add vpx_idct32x32_1_add_c
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct32x32_34_add vpx_idct32x32_34_add_c
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_16_add vpx_idct4x4_16_add_c
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_1_add vpx_idct4x4_1_add_c
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_12_add vpx_idct8x8_12_add_c
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_1_add vpx_idct8x8_1_add_c
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_64_add vpx_idct8x8_64_add_c
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
 #define vpx_int_pro_col vpx_int_pro_col_c
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
 #define vpx_int_pro_row vpx_int_pro_row_c
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_16_add vpx_iwht4x4_16_add_c
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_horizontal_16 vpx_lpf_horizontal_16_c
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
 #define vpx_lpf_horizontal_16_dual vpx_lpf_horizontal_16_dual_c
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
 #define vpx_lpf_horizontal_4 vpx_lpf_horizontal_4_c
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
 #define vpx_lpf_horizontal_4_dual vpx_lpf_horizontal_4_dual_c
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
 #define vpx_lpf_horizontal_8 vpx_lpf_horizontal_8_c
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
 #define vpx_lpf_horizontal_8_dual vpx_lpf_horizontal_8_dual_c
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
 #define vpx_lpf_vertical_16 vpx_lpf_vertical_16_c
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
 #define vpx_lpf_vertical_16_dual vpx_lpf_vertical_16_dual_c
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
 #define vpx_lpf_vertical_4 vpx_lpf_vertical_4_c
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
 #define vpx_lpf_vertical_4_dual vpx_lpf_vertical_4_dual_c
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
 #define vpx_lpf_vertical_8 vpx_lpf_vertical_8_c
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
 #define vpx_lpf_vertical_8_dual vpx_lpf_vertical_8_dual_c
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
 #define vpx_mbpost_proc_across_ip vpx_mbpost_proc_across_ip_c
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
 #define vpx_mbpost_proc_down vpx_mbpost_proc_down_c
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
 #define vpx_minmax_8x8 vpx_minmax_8x8_c
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
 #define vpx_mse16x16 vpx_mse16x16_c
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse16x8 vpx_mse16x8_c
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
 #define vpx_mse8x16 vpx_mse8x16_c
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
 #define vpx_mse8x8 vpx_mse8x8_c
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
 #define vpx_plane_add_noise vpx_plane_add_noise_c
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-#define vpx_post_proc_down_and_across_mb_row vpx_post_proc_down_and_across_mb_row_c
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+#define vpx_post_proc_down_and_across_mb_row \
+  vpx_post_proc_down_and_across_mb_row_c
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
 #define vpx_quantize_b vpx_quantize_b_c
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vpx_quantize_b_32x32 vpx_quantize_b_32x32_c
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad16x16 vpx_sad16x16_c
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad16x16_avg vpx_sad16x16_avg_c
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x3 vpx_sad16x16x3_c
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad16x16x4d vpx_sad16x16x4d_c
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x16x8 vpx_sad16x16x8_c
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad16x32 vpx_sad16x32_c
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad16x32_avg vpx_sad16x32_avg_c
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad16x32x4d vpx_sad16x32x4d_c
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
 #define vpx_sad16x8 vpx_sad16x8_c
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
 #define vpx_sad16x8_avg vpx_sad16x8_avg_c
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x3 vpx_sad16x8x3_c
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad16x8x4d vpx_sad16x8x4d_c
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad16x8x8 vpx_sad16x8x8_c
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x16 vpx_sad32x16_c
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x16_avg vpx_sad32x16_avg_c
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x16x4d vpx_sad32x16x4d_c
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x32 vpx_sad32x32_c
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x32_avg vpx_sad32x32_avg_c
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x32x4d vpx_sad32x32x4d_c
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad32x64 vpx_sad32x64_c
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad32x64_avg vpx_sad32x64_avg_c
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad32x64x4d vpx_sad32x64x4d_c
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad4x4 vpx_sad4x4_c
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad4x4_avg vpx_sad4x4_avg_c
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x3 vpx_sad4x4x3_c
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad4x4x4d vpx_sad4x4x4d_c
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad4x4x8 vpx_sad4x4x8_c
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad4x8 vpx_sad4x8_c
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad4x8_avg vpx_sad4x8_avg_c
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad4x8x4d vpx_sad4x8x4d_c
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad64x32 vpx_sad64x32_c
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad64x32_avg vpx_sad64x32_avg_c
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad64x32x4d vpx_sad64x32x4d_c
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
 #define vpx_sad64x64 vpx_sad64x64_c
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
 #define vpx_sad64x64_avg vpx_sad64x64_avg_c
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
 #define vpx_sad64x64x4d vpx_sad64x64x4d_c
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
 #define vpx_sad8x16 vpx_sad8x16_c
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
 #define vpx_sad8x16_avg vpx_sad8x16_avg_c
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x3 vpx_sad8x16x3_c
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
 #define vpx_sad8x16x4d vpx_sad8x16x4d_c
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x16x8 vpx_sad8x16x8_c
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad8x4 vpx_sad8x4_c
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad8x4_avg vpx_sad8x4_avg_c
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x4x4d vpx_sad8x4x4d_c
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
 #define vpx_sad8x8 vpx_sad8x8_c
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
 #define vpx_sad8x8_avg vpx_sad8x8_avg_c
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x3 vpx_sad8x8x3_c
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
 #define vpx_sad8x8x4d vpx_sad8x8x4d_c
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
 #define vpx_sad8x8x8 vpx_sad8x8x8_c
 
-int vpx_satd_c(const tran_low_t *coeff, int length);
+int vpx_satd_c(const tran_low_t* coeff, int length);
 #define vpx_satd vpx_satd_c
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
 #define vpx_scaled_2d vpx_scaled_2d_c
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x16 vpx_sub_pixel_avg_variance16x16_c
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x32 vpx_sub_pixel_avg_variance16x32_c
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance16x8 vpx_sub_pixel_avg_variance16x8_c
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x16 vpx_sub_pixel_avg_variance32x16_c
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x32 vpx_sub_pixel_avg_variance32x32_c
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance32x64 vpx_sub_pixel_avg_variance32x64_c
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x4 vpx_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance4x8 vpx_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x32 vpx_sub_pixel_avg_variance64x32_c
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance64x64 vpx_sub_pixel_avg_variance64x64_c
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x16 vpx_sub_pixel_avg_variance8x16_c
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x4 vpx_sub_pixel_avg_variance8x4_c
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
 #define vpx_sub_pixel_avg_variance8x8 vpx_sub_pixel_avg_variance8x8_c
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance16x16 vpx_sub_pixel_variance16x16_c
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance16x32 vpx_sub_pixel_variance16x32_c
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
 #define vpx_sub_pixel_variance16x8 vpx_sub_pixel_variance16x8_c
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x16 vpx_sub_pixel_variance32x16_c
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x32 vpx_sub_pixel_variance32x32_c
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance32x64 vpx_sub_pixel_variance32x64_c
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance4x4 vpx_sub_pixel_variance4x4_c
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance4x8 vpx_sub_pixel_variance4x8_c
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance64x32 vpx_sub_pixel_variance64x32_c
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
 #define vpx_sub_pixel_variance64x64 vpx_sub_pixel_variance64x64_c
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
 #define vpx_sub_pixel_variance8x16 vpx_sub_pixel_variance8x16_c
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance8x4 vpx_sub_pixel_variance8x4_c
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
 #define vpx_sub_pixel_variance8x8 vpx_sub_pixel_variance8x8_c
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
 #define vpx_subtract_block vpx_subtract_block_c
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
 #define vpx_sum_squares_2d_i16 vpx_sum_squares_2d_i16_c
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_tm_predictor_16x16 vpx_tm_predictor_16x16_c
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_tm_predictor_32x32 vpx_tm_predictor_32x32_c
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_tm_predictor_4x4 vpx_tm_predictor_4x4_c
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_tm_predictor_8x8 vpx_tm_predictor_8x8_c
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_v_predictor_16x16 vpx_v_predictor_16x16_c
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
 #define vpx_v_predictor_32x32 vpx_v_predictor_32x32_c
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_v_predictor_4x4 vpx_v_predictor_4x4_c
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
 #define vpx_v_predictor_8x8 vpx_v_predictor_8x8_c
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance16x16 vpx_variance16x16_c
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance16x32 vpx_variance16x32_c
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
 #define vpx_variance16x8 vpx_variance16x8_c
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x16 vpx_variance32x16_c
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x32 vpx_variance32x32_c
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance32x64 vpx_variance32x64_c
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance4x4 vpx_variance4x4_c
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance4x8 vpx_variance4x8_c
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance64x32 vpx_variance64x32_c
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
 #define vpx_variance64x64 vpx_variance64x64_c
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
 #define vpx_variance8x16 vpx_variance8x16_c
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance8x4 vpx_variance8x4_c
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
 #define vpx_variance8x8 vpx_variance8x8_c
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
 #define vpx_vector_var vpx_vector_var_c
 
 void vpx_dsp_rtcd(void);
@@ -1512,9 +3804,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/nacl/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/nacl/vpx_scale_rtcd.h b/third_party/libvpx/source/config/nacl/vpx_scale_rtcd.h
index 0098208..6686511 100644
--- a/third_party/libvpx/source/config/nacl/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/nacl/vpx_scale_rtcd.h
@@ -13,43 +13,71 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
@@ -57,9 +85,7 @@
 #include "vpx_config.h"
 
 #ifdef RTCD_C
-static void setup_rtcd_internal(void)
-{
-}
+static void setup_rtcd_internal(void) {}
 #endif
 
 #ifdef __cplusplus

third_party/libvpx/source/config/vpx_version.h

diff --git a/third_party/libvpx/source/config/vpx_version.h b/third_party/libvpx/source/config/vpx_version.h
index d8345c7..9690fa74 100644
--- a/third_party/libvpx/source/config/vpx_version.h
+++ b/third_party/libvpx/source/config/vpx_version.h
@@ -1,7 +1,7 @@
 #define VERSION_MAJOR  1
 #define VERSION_MINOR  6
 #define VERSION_PATCH  1
-#define VERSION_EXTRA  "1007-gc22b17dce"
+#define VERSION_EXTRA  "1034-gcbb83ba4a"
 #define VERSION_PACKED ((VERSION_MAJOR<<16)|(VERSION_MINOR<<8)|(VERSION_PATCH))
-#define VERSION_STRING_NOSP "v1.6.1-1007-gc22b17dce"
-#define VERSION_STRING      " v1.6.1-1007-gc22b17dce"
+#define VERSION_STRING_NOSP "v1.6.1-1034-gcbb83ba4a"
+#define VERSION_STRING      " v1.6.1-1034-gcbb83ba4a"

third_party/libvpx/source/config/win/ia32/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/win/ia32/vp8_rtcd.h b/third_party/libvpx/source/config/win/ia32/vp8_rtcd.h
index 3addf41..2f3a2d3 100644
--- a/third_party/libvpx/source/config/win/ia32/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/win/ia32/vp8_rtcd.h
@@ -26,303 +26,868 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict16x16)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+void vp8_bilinear_predict16x16_sse2(unsigned char* src,
+                                    int src_pitch,
+                                    int xofst,
+                                    int yofst,
+                                    unsigned char* dst,
+                                    int dst_pitch);
+void vp8_bilinear_predict16x16_ssse3(unsigned char* src,
+                                     int src_pitch,
+                                     int xofst,
+                                     int yofst,
+                                     unsigned char* dst,
+                                     int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict16x16)(unsigned char* src,
+                                              int src_pitch,
+                                              int xofst,
+                                              int yofst,
+                                              unsigned char* dst,
+                                              int dst_pitch);
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict4x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict4x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict4x4_mmx(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict4x4)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict8x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x4_mmx(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict8x4)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict8x8)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x8_sse2(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+void vp8_bilinear_predict8x8_ssse3(unsigned char* src,
+                                   int src_pitch,
+                                   int xofst,
+                                   int yofst,
+                                   unsigned char* dst,
+                                   int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict8x8)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
-int vp8_block_error_sse2(short *coeff, short *dqcoeff);
-RTCD_EXTERN int (*vp8_block_error)(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
+int vp8_block_error_sse2(short* coeff, short* dqcoeff);
+RTCD_EXTERN int (*vp8_block_error)(short* coeff, short* dqcoeff);
 
-void vp8_copy32xn_c(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-void vp8_copy32xn_sse2(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-void vp8_copy32xn_sse3(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-RTCD_EXTERN void (*vp8_copy32xn)(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
+void vp8_copy32xn_c(const unsigned char* src_ptr,
+                    int source_stride,
+                    unsigned char* dst_ptr,
+                    int dst_stride,
+                    int n);
+void vp8_copy32xn_sse2(const unsigned char* src_ptr,
+                       int source_stride,
+                       unsigned char* dst_ptr,
+                       int dst_stride,
+                       int n);
+void vp8_copy32xn_sse3(const unsigned char* src_ptr,
+                       int source_stride,
+                       unsigned char* dst_ptr,
+                       int dst_stride,
+                       int n);
+RTCD_EXTERN void (*vp8_copy32xn)(const unsigned char* src_ptr,
+                                 int source_stride,
+                                 unsigned char* dst_ptr,
+                                 int dst_stride,
+                                 int n);
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem16x16_sse2(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_copy_mem16x16)(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+void vp8_copy_mem16x16_sse2(unsigned char* src,
+                            int src_pitch,
+                            unsigned char* dst,
+                            int dst_pitch);
+RTCD_EXTERN void (*vp8_copy_mem16x16)(unsigned char* src,
+                                      int src_pitch,
+                                      unsigned char* dst,
+                                      int dst_pitch);
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x4_mmx(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_copy_mem8x4)(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x4_mmx(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+RTCD_EXTERN void (*vp8_copy_mem8x4)(unsigned char* src,
+                                    int src_pitch,
+                                    unsigned char* dst,
+                                    int dst_pitch);
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x8_mmx(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_copy_mem8x8)(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x8_mmx(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+RTCD_EXTERN void (*vp8_copy_mem8x8)(unsigned char* src,
+                                    int src_pitch,
+                                    unsigned char* dst,
+                                    int dst_pitch);
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-void vp8_dc_only_idct_add_mmx(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-RTCD_EXTERN void (*vp8_dc_only_idct_add)(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_dc_only_idct_add_mmx(short input,
+                              unsigned char* pred,
+                              int pred_stride,
+                              unsigned char* dst,
+                              int dst_stride);
+RTCD_EXTERN void (*vp8_dc_only_idct_add)(short input,
+                                         unsigned char* pred,
+                                         int pred_stride,
+                                         unsigned char* dst,
+                                         int dst_stride);
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_sse2(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-RTCD_EXTERN int (*vp8_denoiser_filter)(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
+int vp8_denoiser_filter_sse2(unsigned char* mc_running_avg_y,
+                             int mc_avg_y_stride,
+                             unsigned char* running_avg_y,
+                             int avg_y_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+RTCD_EXTERN int (*vp8_denoiser_filter)(unsigned char* mc_running_avg_y,
+                                       int mc_avg_y_stride,
+                                       unsigned char* running_avg_y,
+                                       int avg_y_stride,
+                                       unsigned char* sig,
+                                       int sig_stride,
+                                       unsigned int motion_magnitude,
+                                       int increase_denoising);
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_uv_sse2(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-RTCD_EXTERN int (*vp8_denoiser_filter_uv)(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+int vp8_denoiser_filter_uv_sse2(unsigned char* mc_running_avg,
+                                int mc_avg_stride,
+                                unsigned char* running_avg,
+                                int avg_stride,
+                                unsigned char* sig,
+                                int sig_stride,
+                                unsigned int motion_magnitude,
+                                int increase_denoising);
+RTCD_EXTERN int (*vp8_denoiser_filter_uv)(unsigned char* mc_running_avg,
+                                          int mc_avg_stride,
+                                          unsigned char* running_avg,
+                                          int avg_stride,
+                                          unsigned char* sig,
+                                          int sig_stride,
+                                          unsigned int motion_magnitude,
+                                          int increase_denoising);
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
-void vp8_dequant_idct_add_mmx(short *input, short *dq, unsigned char *output, int stride);
-RTCD_EXTERN void (*vp8_dequant_idct_add)(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
+void vp8_dequant_idct_add_mmx(short* input,
+                              short* dq,
+                              unsigned char* output,
+                              int stride);
+RTCD_EXTERN void (*vp8_dequant_idct_add)(short* input,
+                                         short* dq,
+                                         unsigned char* output,
+                                         int stride);
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-void vp8_dequant_idct_add_uv_block_sse2(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-RTCD_EXTERN void (*vp8_dequant_idct_add_uv_block)(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
+void vp8_dequant_idct_add_uv_block_sse2(short* q,
+                                        short* dq,
+                                        unsigned char* dst_u,
+                                        unsigned char* dst_v,
+                                        int stride,
+                                        char* eobs);
+RTCD_EXTERN void (*vp8_dequant_idct_add_uv_block)(short* q,
+                                                  short* dq,
+                                                  unsigned char* dst_u,
+                                                  unsigned char* dst_v,
+                                                  int stride,
+                                                  char* eobs);
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-void vp8_dequant_idct_add_y_block_sse2(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-RTCD_EXTERN void (*vp8_dequant_idct_add_y_block)(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
+void vp8_dequant_idct_add_y_block_sse2(short* q,
+                                       short* dq,
+                                       unsigned char* dst,
+                                       int stride,
+                                       char* eobs);
+RTCD_EXTERN void (*vp8_dequant_idct_add_y_block)(short* q,
+                                                 short* dq,
+                                                 unsigned char* dst,
+                                                 int stride,
+                                                 char* eobs);
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
-void vp8_dequantize_b_mmx(struct blockd*, short *dqc);
-RTCD_EXTERN void (*vp8_dequantize_b)(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
+void vp8_dequantize_b_mmx(struct blockd*, short* dqc);
+RTCD_EXTERN void (*vp8_dequantize_b)(struct blockd*, short* dqc);
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_diamond_search_sadx4(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-RTCD_EXTERN int (*vp8_diamond_search_sad)(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
+int vp8_diamond_search_sadx4(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
+RTCD_EXTERN int (*vp8_diamond_search_sad)(struct macroblock* x,
+                                          struct block* b,
+                                          struct blockd* d,
+                                          union int_mv* ref_mv,
+                                          union int_mv* best_mv,
+                                          int search_param,
+                                          int sad_per_bit,
+                                          int* num00,
+                                          struct variance_vtable* fn_ptr,
+                                          int* mvcost[2],
+                                          union int_mv* center_mv);
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
-void vp8_fast_quantize_b_sse2(struct block *, struct blockd *);
-void vp8_fast_quantize_b_ssse3(struct block *, struct blockd *);
-RTCD_EXTERN void (*vp8_fast_quantize_b)(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
+void vp8_fast_quantize_b_sse2(struct block*, struct blockd*);
+void vp8_fast_quantize_b_ssse3(struct block*, struct blockd*);
+RTCD_EXTERN void (*vp8_fast_quantize_b)(struct block*, struct blockd*);
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-void vp8_filter_by_weight16x16_sse2(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-RTCD_EXTERN void (*vp8_filter_by_weight16x16)(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
+void vp8_filter_by_weight16x16_sse2(unsigned char* src,
+                                    int src_stride,
+                                    unsigned char* dst,
+                                    int dst_stride,
+                                    int src_weight);
+RTCD_EXTERN void (*vp8_filter_by_weight16x16)(unsigned char* src,
+                                              int src_stride,
+                                              unsigned char* dst,
+                                              int dst_stride,
+                                              int src_weight);
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-void vp8_filter_by_weight8x8_sse2(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-RTCD_EXTERN void (*vp8_filter_by_weight8x8)(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
+void vp8_filter_by_weight8x8_sse2(unsigned char* src,
+                                  int src_stride,
+                                  unsigned char* dst,
+                                  int dst_stride,
+                                  int src_weight);
+RTCD_EXTERN void (*vp8_filter_by_weight8x8)(unsigned char* src,
+                                            int src_stride,
+                                            unsigned char* dst,
+                                            int dst_stride,
+                                            int src_weight);
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_full_search_sadx3(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_full_search_sadx8(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-RTCD_EXTERN int (*vp8_full_search_sad)(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+int vp8_full_search_sadx3(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+int vp8_full_search_sadx8(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+RTCD_EXTERN int (*vp8_full_search_sad)(struct macroblock* x,
+                                       struct block* b,
+                                       struct blockd* d,
+                                       union int_mv* ref_mv,
+                                       int sad_per_bit,
+                                       int distance,
+                                       struct variance_vtable* fn_ptr,
+                                       int* mvcost[2],
+                                       union int_mv* center_mv);
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bh_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_bh)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bh_sse2(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_bh)(unsigned char* y,
+                                       unsigned char* u,
+                                       unsigned char* v,
+                                       int ystride,
+                                       int uv_stride,
+                                       struct loop_filter_info* lfi);
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bv_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_bv)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bv_sse2(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_bv)(unsigned char* y,
+                                       unsigned char* u,
+                                       unsigned char* v,
+                                       int ystride,
+                                       int uv_stride,
+                                       struct loop_filter_info* lfi);
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbh_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_mbh)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbh_sse2(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_mbh)(unsigned char* y,
+                                        unsigned char* u,
+                                        unsigned char* v,
+                                        int ystride,
+                                        int uv_stride,
+                                        struct loop_filter_info* lfi);
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbv_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-RTCD_EXTERN void (*vp8_loop_filter_mbv)(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbv_sse2(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
+RTCD_EXTERN void (*vp8_loop_filter_mbv)(unsigned char* y,
+                                        unsigned char* u,
+                                        unsigned char* v,
+                                        int ystride,
+                                        int uv_stride,
+                                        struct loop_filter_info* lfi);
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bhs_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_bh)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bhs_sse2(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_bh)(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bvs_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_bv)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bvs_sse2(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_bv)(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_simple_horizontal_edge_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_mbh)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
+void vp8_loop_filter_simple_horizontal_edge_sse2(unsigned char* y,
+                                                 int ystride,
+                                                 const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_mbh)(unsigned char* y,
+                                               int ystride,
+                                               const unsigned char* blimit);
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_simple_vertical_edge_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
-RTCD_EXTERN void (*vp8_loop_filter_simple_mbv)(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
+void vp8_loop_filter_simple_vertical_edge_sse2(unsigned char* y,
+                                               int ystride,
+                                               const unsigned char* blimit);
+RTCD_EXTERN void (*vp8_loop_filter_simple_mbv)(unsigned char* y,
+                                               int ystride,
+                                               const unsigned char* blimit);
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
-int vp8_mbblock_error_sse2(struct macroblock *mb, int dc);
-RTCD_EXTERN int (*vp8_mbblock_error)(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
+int vp8_mbblock_error_sse2(struct macroblock* mb, int dc);
+RTCD_EXTERN int (*vp8_mbblock_error)(struct macroblock* mb, int dc);
 
-int vp8_mbuverror_c(struct macroblock *mb);
-int vp8_mbuverror_sse2(struct macroblock *mb);
-RTCD_EXTERN int (*vp8_mbuverror)(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
+int vp8_mbuverror_sse2(struct macroblock* mb);
+RTCD_EXTERN int (*vp8_mbuverror)(struct macroblock* mb);
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_refining_search_sadx4(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-RTCD_EXTERN int (*vp8_refining_search_sad)(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
+int vp8_refining_search_sadx4(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
+RTCD_EXTERN int (*vp8_refining_search_sad)(struct macroblock* x,
+                                           struct block* b,
+                                           struct blockd* d,
+                                           union int_mv* ref_mv,
+                                           int sad_per_bit,
+                                           int distance,
+                                           struct variance_vtable* fn_ptr,
+                                           int* mvcost[2],
+                                           union int_mv* center_mv);
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
-void vp8_regular_quantize_b_sse2(struct block *, struct blockd *);
-void vp8_regular_quantize_b_sse4_1(struct block *, struct blockd *);
-RTCD_EXTERN void (*vp8_regular_quantize_b)(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
+void vp8_regular_quantize_b_sse2(struct block*, struct blockd*);
+void vp8_regular_quantize_b_sse4_1(struct block*, struct blockd*);
+RTCD_EXTERN void (*vp8_regular_quantize_b)(struct block*, struct blockd*);
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct4x4_sse2(short *input, short *output, int pitch);
-RTCD_EXTERN void (*vp8_short_fdct4x4)(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct4x4_sse2(short* input, short* output, int pitch);
+RTCD_EXTERN void (*vp8_short_fdct4x4)(short* input, short* output, int pitch);
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct8x4_sse2(short *input, short *output, int pitch);
-RTCD_EXTERN void (*vp8_short_fdct8x4)(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct8x4_sse2(short* input, short* output, int pitch);
+RTCD_EXTERN void (*vp8_short_fdct8x4)(short* input, short* output, int pitch);
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-void vp8_short_idct4x4llm_mmx(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-RTCD_EXTERN void (*vp8_short_idct4x4llm)(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_short_idct4x4llm_mmx(short* input,
+                              unsigned char* pred,
+                              int pitch,
+                              unsigned char* dst,
+                              int dst_stride);
+RTCD_EXTERN void (*vp8_short_idct4x4llm)(short* input,
+                                         unsigned char* pred,
+                                         int pitch,
+                                         unsigned char* dst,
+                                         int dst_stride);
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
-void vp8_short_inv_walsh4x4_sse2(short *input, short *output);
-RTCD_EXTERN void (*vp8_short_inv_walsh4x4)(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
+void vp8_short_inv_walsh4x4_sse2(short* input, short* output);
+RTCD_EXTERN void (*vp8_short_inv_walsh4x4)(short* input, short* output);
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
-void vp8_short_walsh4x4_sse2(short *input, short *output, int pitch);
-RTCD_EXTERN void (*vp8_short_walsh4x4)(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
+void vp8_short_walsh4x4_sse2(short* input, short* output, int pitch);
+RTCD_EXTERN void (*vp8_short_walsh4x4)(short* input, short* output, int pitch);
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict16x16)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict16x16_sse2(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+void vp8_sixtap_predict16x16_ssse3(unsigned char* src,
+                                   int src_pitch,
+                                   int xofst,
+                                   int yofst,
+                                   unsigned char* dst,
+                                   int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict16x16)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict4x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict4x4_mmx(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict4x4_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict4x4)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict8x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x4_sse2(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+void vp8_sixtap_predict8x4_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict8x4)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict8x8)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x8_sse2(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+void vp8_sixtap_predict8x8_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict8x8)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
 void vp8_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_c;
-    if (flags & HAS_SSE2) vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_sse2;
-    if (flags & HAS_SSSE3) vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_ssse3;
-    vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_c;
-    if (flags & HAS_MMX) vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_mmx;
-    vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_c;
-    if (flags & HAS_MMX) vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_mmx;
-    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_c;
-    if (flags & HAS_SSE2) vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_sse2;
-    if (flags & HAS_SSSE3) vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_ssse3;
-    vp8_block_error = vp8_block_error_c;
-    if (flags & HAS_SSE2) vp8_block_error = vp8_block_error_sse2;
-    vp8_copy32xn = vp8_copy32xn_c;
-    if (flags & HAS_SSE2) vp8_copy32xn = vp8_copy32xn_sse2;
-    if (flags & HAS_SSE3) vp8_copy32xn = vp8_copy32xn_sse3;
-    vp8_copy_mem16x16 = vp8_copy_mem16x16_c;
-    if (flags & HAS_SSE2) vp8_copy_mem16x16 = vp8_copy_mem16x16_sse2;
-    vp8_copy_mem8x4 = vp8_copy_mem8x4_c;
-    if (flags & HAS_MMX) vp8_copy_mem8x4 = vp8_copy_mem8x4_mmx;
-    vp8_copy_mem8x8 = vp8_copy_mem8x8_c;
-    if (flags & HAS_MMX) vp8_copy_mem8x8 = vp8_copy_mem8x8_mmx;
-    vp8_dc_only_idct_add = vp8_dc_only_idct_add_c;
-    if (flags & HAS_MMX) vp8_dc_only_idct_add = vp8_dc_only_idct_add_mmx;
-    vp8_denoiser_filter = vp8_denoiser_filter_c;
-    if (flags & HAS_SSE2) vp8_denoiser_filter = vp8_denoiser_filter_sse2;
-    vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_c;
-    if (flags & HAS_SSE2) vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_sse2;
-    vp8_dequant_idct_add = vp8_dequant_idct_add_c;
-    if (flags & HAS_MMX) vp8_dequant_idct_add = vp8_dequant_idct_add_mmx;
-    vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_c;
-    if (flags & HAS_SSE2) vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_sse2;
-    vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_c;
-    if (flags & HAS_SSE2) vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_sse2;
-    vp8_dequantize_b = vp8_dequantize_b_c;
-    if (flags & HAS_MMX) vp8_dequantize_b = vp8_dequantize_b_mmx;
-    vp8_diamond_search_sad = vp8_diamond_search_sad_c;
-    if (flags & HAS_SSE2) vp8_diamond_search_sad = vp8_diamond_search_sadx4;
-    vp8_fast_quantize_b = vp8_fast_quantize_b_c;
-    if (flags & HAS_SSE2) vp8_fast_quantize_b = vp8_fast_quantize_b_sse2;
-    if (flags & HAS_SSSE3) vp8_fast_quantize_b = vp8_fast_quantize_b_ssse3;
-    vp8_filter_by_weight16x16 = vp8_filter_by_weight16x16_c;
-    if (flags & HAS_SSE2) vp8_filter_by_weight16x16 = vp8_filter_by_weight16x16_sse2;
-    vp8_filter_by_weight8x8 = vp8_filter_by_weight8x8_c;
-    if (flags & HAS_SSE2) vp8_filter_by_weight8x8 = vp8_filter_by_weight8x8_sse2;
-    vp8_full_search_sad = vp8_full_search_sad_c;
-    if (flags & HAS_SSE3) vp8_full_search_sad = vp8_full_search_sadx3;
-    if (flags & HAS_SSE4_1) vp8_full_search_sad = vp8_full_search_sadx8;
-    vp8_loop_filter_bh = vp8_loop_filter_bh_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_bh = vp8_loop_filter_bh_sse2;
-    vp8_loop_filter_bv = vp8_loop_filter_bv_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_bv = vp8_loop_filter_bv_sse2;
-    vp8_loop_filter_mbh = vp8_loop_filter_mbh_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_mbh = vp8_loop_filter_mbh_sse2;
-    vp8_loop_filter_mbv = vp8_loop_filter_mbv_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_mbv = vp8_loop_filter_mbv_sse2;
-    vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_sse2;
-    vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_sse2;
-    vp8_loop_filter_simple_mbh = vp8_loop_filter_simple_horizontal_edge_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_simple_mbh = vp8_loop_filter_simple_horizontal_edge_sse2;
-    vp8_loop_filter_simple_mbv = vp8_loop_filter_simple_vertical_edge_c;
-    if (flags & HAS_SSE2) vp8_loop_filter_simple_mbv = vp8_loop_filter_simple_vertical_edge_sse2;
-    vp8_mbblock_error = vp8_mbblock_error_c;
-    if (flags & HAS_SSE2) vp8_mbblock_error = vp8_mbblock_error_sse2;
-    vp8_mbuverror = vp8_mbuverror_c;
-    if (flags & HAS_SSE2) vp8_mbuverror = vp8_mbuverror_sse2;
-    vp8_refining_search_sad = vp8_refining_search_sad_c;
-    if (flags & HAS_SSE2) vp8_refining_search_sad = vp8_refining_search_sadx4;
-    vp8_regular_quantize_b = vp8_regular_quantize_b_c;
-    if (flags & HAS_SSE2) vp8_regular_quantize_b = vp8_regular_quantize_b_sse2;
-    if (flags & HAS_SSE4_1) vp8_regular_quantize_b = vp8_regular_quantize_b_sse4_1;
-    vp8_short_fdct4x4 = vp8_short_fdct4x4_c;
-    if (flags & HAS_SSE2) vp8_short_fdct4x4 = vp8_short_fdct4x4_sse2;
-    vp8_short_fdct8x4 = vp8_short_fdct8x4_c;
-    if (flags & HAS_SSE2) vp8_short_fdct8x4 = vp8_short_fdct8x4_sse2;
-    vp8_short_idct4x4llm = vp8_short_idct4x4llm_c;
-    if (flags & HAS_MMX) vp8_short_idct4x4llm = vp8_short_idct4x4llm_mmx;
-    vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_c;
-    if (flags & HAS_SSE2) vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_sse2;
-    vp8_short_walsh4x4 = vp8_short_walsh4x4_c;
-    if (flags & HAS_SSE2) vp8_short_walsh4x4 = vp8_short_walsh4x4_sse2;
-    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_c;
-    if (flags & HAS_SSE2) vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_ssse3;
-    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_c;
-    if (flags & HAS_MMX) vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_mmx;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_ssse3;
-    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_c;
-    if (flags & HAS_SSE2) vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_ssse3;
-    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_c;
-    if (flags & HAS_SSE2) vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_ssse3;
+  vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_c;
+  if (flags & HAS_SSE2)
+    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_ssse3;
+  vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_c;
+  if (flags & HAS_MMX)
+    vp8_bilinear_predict4x4 = vp8_bilinear_predict4x4_mmx;
+  vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_c;
+  if (flags & HAS_MMX)
+    vp8_bilinear_predict8x4 = vp8_bilinear_predict8x4_mmx;
+  vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_c;
+  if (flags & HAS_SSE2)
+    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_ssse3;
+  vp8_block_error = vp8_block_error_c;
+  if (flags & HAS_SSE2)
+    vp8_block_error = vp8_block_error_sse2;
+  vp8_copy32xn = vp8_copy32xn_c;
+  if (flags & HAS_SSE2)
+    vp8_copy32xn = vp8_copy32xn_sse2;
+  if (flags & HAS_SSE3)
+    vp8_copy32xn = vp8_copy32xn_sse3;
+  vp8_copy_mem16x16 = vp8_copy_mem16x16_c;
+  if (flags & HAS_SSE2)
+    vp8_copy_mem16x16 = vp8_copy_mem16x16_sse2;
+  vp8_copy_mem8x4 = vp8_copy_mem8x4_c;
+  if (flags & HAS_MMX)
+    vp8_copy_mem8x4 = vp8_copy_mem8x4_mmx;
+  vp8_copy_mem8x8 = vp8_copy_mem8x8_c;
+  if (flags & HAS_MMX)
+    vp8_copy_mem8x8 = vp8_copy_mem8x8_mmx;
+  vp8_dc_only_idct_add = vp8_dc_only_idct_add_c;
+  if (flags & HAS_MMX)
+    vp8_dc_only_idct_add = vp8_dc_only_idct_add_mmx;
+  vp8_denoiser_filter = vp8_denoiser_filter_c;
+  if (flags & HAS_SSE2)
+    vp8_denoiser_filter = vp8_denoiser_filter_sse2;
+  vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_c;
+  if (flags & HAS_SSE2)
+    vp8_denoiser_filter_uv = vp8_denoiser_filter_uv_sse2;
+  vp8_dequant_idct_add = vp8_dequant_idct_add_c;
+  if (flags & HAS_MMX)
+    vp8_dequant_idct_add = vp8_dequant_idct_add_mmx;
+  vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_c;
+  if (flags & HAS_SSE2)
+    vp8_dequant_idct_add_uv_block = vp8_dequant_idct_add_uv_block_sse2;
+  vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_c;
+  if (flags & HAS_SSE2)
+    vp8_dequant_idct_add_y_block = vp8_dequant_idct_add_y_block_sse2;
+  vp8_dequantize_b = vp8_dequantize_b_c;
+  if (flags & HAS_MMX)
+    vp8_dequantize_b = vp8_dequantize_b_mmx;
+  vp8_diamond_search_sad = vp8_diamond_search_sad_c;
+  if (flags & HAS_SSE2)
+    vp8_diamond_search_sad = vp8_diamond_search_sadx4;
+  vp8_fast_quantize_b = vp8_fast_quantize_b_c;
+  if (flags & HAS_SSE2)
+    vp8_fast_quantize_b = vp8_fast_quantize_b_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_fast_quantize_b = vp8_fast_quantize_b_ssse3;
+  vp8_filter_by_weight16x16 = vp8_filter_by_weight16x16_c;
+  if (flags & HAS_SSE2)
+    vp8_filter_by_weight16x16 = vp8_filter_by_weight16x16_sse2;
+  vp8_filter_by_weight8x8 = vp8_filter_by_weight8x8_c;
+  if (flags & HAS_SSE2)
+    vp8_filter_by_weight8x8 = vp8_filter_by_weight8x8_sse2;
+  vp8_full_search_sad = vp8_full_search_sad_c;
+  if (flags & HAS_SSE3)
+    vp8_full_search_sad = vp8_full_search_sadx3;
+  if (flags & HAS_SSE4_1)
+    vp8_full_search_sad = vp8_full_search_sadx8;
+  vp8_loop_filter_bh = vp8_loop_filter_bh_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_bh = vp8_loop_filter_bh_sse2;
+  vp8_loop_filter_bv = vp8_loop_filter_bv_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_bv = vp8_loop_filter_bv_sse2;
+  vp8_loop_filter_mbh = vp8_loop_filter_mbh_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_mbh = vp8_loop_filter_mbh_sse2;
+  vp8_loop_filter_mbv = vp8_loop_filter_mbv_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_mbv = vp8_loop_filter_mbv_sse2;
+  vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_simple_bh = vp8_loop_filter_bhs_sse2;
+  vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_simple_bv = vp8_loop_filter_bvs_sse2;
+  vp8_loop_filter_simple_mbh = vp8_loop_filter_simple_horizontal_edge_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_simple_mbh = vp8_loop_filter_simple_horizontal_edge_sse2;
+  vp8_loop_filter_simple_mbv = vp8_loop_filter_simple_vertical_edge_c;
+  if (flags & HAS_SSE2)
+    vp8_loop_filter_simple_mbv = vp8_loop_filter_simple_vertical_edge_sse2;
+  vp8_mbblock_error = vp8_mbblock_error_c;
+  if (flags & HAS_SSE2)
+    vp8_mbblock_error = vp8_mbblock_error_sse2;
+  vp8_mbuverror = vp8_mbuverror_c;
+  if (flags & HAS_SSE2)
+    vp8_mbuverror = vp8_mbuverror_sse2;
+  vp8_refining_search_sad = vp8_refining_search_sad_c;
+  if (flags & HAS_SSE2)
+    vp8_refining_search_sad = vp8_refining_search_sadx4;
+  vp8_regular_quantize_b = vp8_regular_quantize_b_c;
+  if (flags & HAS_SSE2)
+    vp8_regular_quantize_b = vp8_regular_quantize_b_sse2;
+  if (flags & HAS_SSE4_1)
+    vp8_regular_quantize_b = vp8_regular_quantize_b_sse4_1;
+  vp8_short_fdct4x4 = vp8_short_fdct4x4_c;
+  if (flags & HAS_SSE2)
+    vp8_short_fdct4x4 = vp8_short_fdct4x4_sse2;
+  vp8_short_fdct8x4 = vp8_short_fdct8x4_c;
+  if (flags & HAS_SSE2)
+    vp8_short_fdct8x4 = vp8_short_fdct8x4_sse2;
+  vp8_short_idct4x4llm = vp8_short_idct4x4llm_c;
+  if (flags & HAS_MMX)
+    vp8_short_idct4x4llm = vp8_short_idct4x4llm_mmx;
+  vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_c;
+  if (flags & HAS_SSE2)
+    vp8_short_inv_walsh4x4 = vp8_short_inv_walsh4x4_sse2;
+  vp8_short_walsh4x4 = vp8_short_walsh4x4_c;
+  if (flags & HAS_SSE2)
+    vp8_short_walsh4x4 = vp8_short_walsh4x4_sse2;
+  vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_c;
+  if (flags & HAS_SSE2)
+    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_ssse3;
+  vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_c;
+  if (flags & HAS_MMX)
+    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_mmx;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_ssse3;
+  vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_c;
+  if (flags & HAS_SSE2)
+    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_ssse3;
+  vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_c;
+  if (flags & HAS_SSE2)
+    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_ssse3;
 }
 #endif
 

third_party/libvpx/source/config/win/ia32/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/win/ia32/vp9_rtcd.h b/third_party/libvpx/source/config/win/ia32/vp9_rtcd.h
index 2609a0d..33014a3 100644
--- a/third_party/libvpx/source/config/win/ia32/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/win/ia32/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,168 +30,519 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-int64_t vp9_block_error_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-int64_t vp9_block_error_avx2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-RTCD_EXTERN int64_t (*vp9_block_error)(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
+int64_t vp9_block_error_sse2(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             intptr_t block_size,
+                             int64_t* ssz);
+int64_t vp9_block_error_avx2(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             intptr_t block_size,
+                             int64_t* ssz);
+RTCD_EXTERN int64_t (*vp9_block_error)(const tran_low_t* coeff,
+                                       const tran_low_t* dqcoeff,
+                                       intptr_t block_size,
+                                       int64_t* ssz);
 
-int64_t vp9_block_error_fp_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
-int64_t vp9_block_error_fp_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
-RTCD_EXTERN int64_t (*vp9_block_error_fp)(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             int block_size);
+int64_t vp9_block_error_fp_sse2(const tran_low_t* coeff,
+                                const tran_low_t* dqcoeff,
+                                int block_size);
+RTCD_EXTERN int64_t (*vp9_block_error_fp)(const tran_low_t* coeff,
+                                          const tran_low_t* dqcoeff,
+                                          int block_size);
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-int vp9_denoiser_filter_sse2(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-RTCD_EXTERN int (*vp9_denoiser_filter)(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
+int vp9_denoiser_filter_sse2(const uint8_t* sig,
+                             int sig_stride,
+                             const uint8_t* mc_avg,
+                             int mc_avg_stride,
+                             uint8_t* avg,
+                             int avg_stride,
+                             int increase_denoising,
+                             BLOCK_SIZE bs,
+                             int motion_magnitude);
+RTCD_EXTERN int (*vp9_denoiser_filter)(const uint8_t* sig,
+                                       int sig_stride,
+                                       const uint8_t* mc_avg,
+                                       int mc_avg_stride,
+                                       uint8_t* avg,
+                                       int avg_stride,
+                                       int increase_denoising,
+                                       BLOCK_SIZE bs,
+                                       int motion_magnitude);
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
-int vp9_diamond_search_sad_avx(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
-RTCD_EXTERN int (*vp9_diamond_search_sad)(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
+int vp9_diamond_search_sad_avx(const struct macroblock* x,
+                               const struct search_site_config* cfg,
+                               struct mv* ref_mv,
+                               struct mv* best_mv,
+                               int search_param,
+                               int sad_per_bit,
+                               int* num00,
+                               const struct vp9_variance_vtable* fn_ptr,
+                               const struct mv* center_mv);
+RTCD_EXTERN int (*vp9_diamond_search_sad)(
+    const struct macroblock* x,
+    const struct search_site_config* cfg,
+    struct mv* ref_mv,
+    struct mv* best_mv,
+    int search_param,
+    int sad_per_bit,
+    int* num00,
+    const struct vp9_variance_vtable* fn_ptr,
+    const struct mv* center_mv);
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_fdct8x8_quant_ssse3(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_fdct8x8_quant)(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+void vp9_fdct8x8_quant_ssse3(const int16_t* input,
+                             int stride,
+                             tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+RTCD_EXTERN void (*vp9_fdct8x8_quant)(const int16_t* input,
+                                      int stride,
+                                      tran_low_t* coeff_ptr,
+                                      intptr_t n_coeffs,
+                                      int skip_block,
+                                      const int16_t* round_ptr,
+                                      const int16_t* quant_ptr,
+                                      tran_low_t* qcoeff_ptr,
+                                      tran_low_t* dqcoeff_ptr,
+                                      const int16_t* dequant_ptr,
+                                      uint16_t* eob_ptr,
+                                      const int16_t* scan,
+                                      const int16_t* iscan);
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht16x16_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_fht16x16)(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
+void vp9_fht16x16_sse2(const int16_t* input,
+                       tran_low_t* output,
+                       int stride,
+                       int tx_type);
+RTCD_EXTERN void (*vp9_fht16x16)(const int16_t* input,
+                                 tran_low_t* output,
+                                 int stride,
+                                 int tx_type);
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht4x4_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_fht4x4)(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
+void vp9_fht4x4_sse2(const int16_t* input,
+                     tran_low_t* output,
+                     int stride,
+                     int tx_type);
+RTCD_EXTERN void (*vp9_fht4x4)(const int16_t* input,
+                               tran_low_t* output,
+                               int stride,
+                               int tx_type);
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht8x8_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_fht8x8)(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
+void vp9_fht8x8_sse2(const int16_t* input,
+                     tran_low_t* output,
+                     int stride,
+                     int tx_type);
+RTCD_EXTERN void (*vp9_fht8x8)(const int16_t* input,
+                               tran_low_t* output,
+                               int stride,
+                               int tx_type);
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-void vp9_filter_by_weight16x16_sse2(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-RTCD_EXTERN void (*vp9_filter_by_weight16x16)(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
+void vp9_filter_by_weight16x16_sse2(const uint8_t* src,
+                                    int src_stride,
+                                    uint8_t* dst,
+                                    int dst_stride,
+                                    int src_weight);
+RTCD_EXTERN void (*vp9_filter_by_weight16x16)(const uint8_t* src,
+                                              int src_stride,
+                                              uint8_t* dst,
+                                              int dst_stride,
+                                              int src_weight);
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-void vp9_filter_by_weight8x8_sse2(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-RTCD_EXTERN void (*vp9_filter_by_weight8x8)(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
+void vp9_filter_by_weight8x8_sse2(const uint8_t* src,
+                                  int src_stride,
+                                  uint8_t* dst,
+                                  int dst_stride,
+                                  int src_weight);
+RTCD_EXTERN void (*vp9_filter_by_weight8x8)(const uint8_t* src,
+                                            int src_stride,
+                                            uint8_t* dst,
+                                            int dst_stride,
+                                            int src_weight);
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vp9_fwht4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vp9_fwht4x4)(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vp9_fwht4x4_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vp9_fwht4x4)(const int16_t* input,
+                                tran_low_t* output,
+                                int stride);
 
-int64_t vp9_highbd_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
-int64_t vp9_highbd_block_error_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
-RTCD_EXTERN int64_t (*vp9_highbd_block_error)(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
+int64_t vp9_highbd_block_error_c(const tran_low_t* coeff,
+                                 const tran_low_t* dqcoeff,
+                                 intptr_t block_size,
+                                 int64_t* ssz,
+                                 int bd);
+int64_t vp9_highbd_block_error_sse2(const tran_low_t* coeff,
+                                    const tran_low_t* dqcoeff,
+                                    intptr_t block_size,
+                                    int64_t* ssz,
+                                    int bd);
+RTCD_EXTERN int64_t (*vp9_highbd_block_error)(const tran_low_t* coeff,
+                                              const tran_low_t* dqcoeff,
+                                              intptr_t block_size,
+                                              int64_t* ssz,
+                                              int bd);
 
-void vp9_highbd_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht16x16_c(const int16_t* input,
+                           tran_low_t* output,
+                           int stride,
+                           int tx_type);
 #define vp9_highbd_fht16x16 vp9_highbd_fht16x16_c
 
-void vp9_highbd_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht4x4_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht4x4 vp9_highbd_fht4x4_c
 
-void vp9_highbd_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht8x8_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht8x8 vp9_highbd_fht8x8_c
 
-void vp9_highbd_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_highbd_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_highbd_fwht4x4 vp9_highbd_fwht4x4_c
 
-void vp9_highbd_iht16x16_256_add_c(const tran_low_t *input, uint16_t *output, int pitch, int tx_type, int bd);
+void vp9_highbd_iht16x16_256_add_c(const tran_low_t* input,
+                                   uint16_t* output,
+                                   int pitch,
+                                   int tx_type,
+                                   int bd);
 #define vp9_highbd_iht16x16_256_add vp9_highbd_iht16x16_256_add_c
 
-void vp9_highbd_iht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht4x4_16_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht4x4_16_add vp9_highbd_iht4x4_16_add_c
 
-void vp9_highbd_iht8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht8x8_64_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht8x8_64_add vp9_highbd_iht8x8_64_add_c
 
-void vp9_highbd_mbpost_proc_across_ip_c(uint16_t *src, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_across_ip_c(uint16_t* src,
+                                        int pitch,
+                                        int rows,
+                                        int cols,
+                                        int flimit);
 #define vp9_highbd_mbpost_proc_across_ip vp9_highbd_mbpost_proc_across_ip_c
 
-void vp9_highbd_mbpost_proc_down_c(uint16_t *dst, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_down_c(uint16_t* dst,
+                                   int pitch,
+                                   int rows,
+                                   int cols,
+                                   int flimit);
 #define vp9_highbd_mbpost_proc_down vp9_highbd_mbpost_proc_down_c
 
-void vp9_highbd_post_proc_down_and_across_c(const uint16_t *src_ptr, uint16_t *dst_ptr, int src_pixels_per_line, int dst_pixels_per_line, int rows, int cols, int flimit);
-#define vp9_highbd_post_proc_down_and_across vp9_highbd_post_proc_down_and_across_c
+void vp9_highbd_post_proc_down_and_across_c(const uint16_t* src_ptr,
+                                            uint16_t* dst_ptr,
+                                            int src_pixels_per_line,
+                                            int dst_pixels_per_line,
+                                            int rows,
+                                            int cols,
+                                            int flimit);
+#define vp9_highbd_post_proc_down_and_across \
+  vp9_highbd_post_proc_down_and_across_c
 
-void vp9_highbd_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_c(const tran_low_t* coeff_ptr,
+                              intptr_t n_coeffs,
+                              int skip_block,
+                              const int16_t* round_ptr,
+                              const int16_t* quant_ptr,
+                              tran_low_t* qcoeff_ptr,
+                              tran_low_t* dqcoeff_ptr,
+                              const int16_t* dequant_ptr,
+                              uint16_t* eob_ptr,
+                              const int16_t* scan,
+                              const int16_t* iscan);
 #define vp9_highbd_quantize_fp vp9_highbd_quantize_fp_c
 
-void vp9_highbd_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 #define vp9_highbd_quantize_fp_32x32 vp9_highbd_quantize_fp_32x32_c
 
-void vp9_highbd_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_highbd_temporal_filter_apply_c(const uint8_t* frame1,
+                                        unsigned int stride,
+                                        const uint8_t* frame2,
+                                        unsigned int block_width,
+                                        unsigned int block_height,
+                                        int strength,
+                                        int filter_weight,
+                                        uint32_t* accumulator,
+                                        uint16_t* count);
 #define vp9_highbd_temporal_filter_apply vp9_highbd_temporal_filter_apply_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
-void vp9_iht16x16_256_add_sse2(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
-RTCD_EXTERN void (*vp9_iht16x16_256_add)(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
+void vp9_iht16x16_256_add_sse2(const tran_low_t* input,
+                               uint8_t* output,
+                               int pitch,
+                               int tx_type);
+RTCD_EXTERN void (*vp9_iht16x16_256_add)(const tran_low_t* input,
+                                         uint8_t* output,
+                                         int pitch,
+                                         int tx_type);
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_iht4x4_16_add)(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht4x4_16_add_sse2(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
+RTCD_EXTERN void (*vp9_iht4x4_16_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride,
+                                      int tx_type);
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht8x8_64_add_sse2(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-RTCD_EXTERN void (*vp9_iht8x8_64_add)(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht8x8_64_add_sse2(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
+RTCD_EXTERN void (*vp9_iht8x8_64_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride,
+                                      int tx_type);
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_quantize_fp)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
+void vp9_quantize_fp_sse2(const tran_low_t* coeff_ptr,
+                          intptr_t n_coeffs,
+                          int skip_block,
+                          const int16_t* round_ptr,
+                          const int16_t* quant_ptr,
+                          tran_low_t* qcoeff_ptr,
+                          tran_low_t* dqcoeff_ptr,
+                          const int16_t* dequant_ptr,
+                          uint16_t* eob_ptr,
+                          const int16_t* scan,
+                          const int16_t* iscan);
+RTCD_EXTERN void (*vp9_quantize_fp)(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
 #define vp9_quantize_fp_32x32 vp9_quantize_fp_32x32_c
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
-void vp9_scale_and_extend_frame_ssse3(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
-RTCD_EXTERN void (*vp9_scale_and_extend_frame)(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
+void vp9_scale_and_extend_frame_ssse3(const struct yv12_buffer_config* src,
+                                      struct yv12_buffer_config* dst,
+                                      INTERP_FILTER filter_type,
+                                      int phase_scaler);
+RTCD_EXTERN void (*vp9_scale_and_extend_frame)(
+    const struct yv12_buffer_config* src,
+    struct yv12_buffer_config* dst,
+    INTERP_FILTER filter_type,
+    int phase_scaler);
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
-void vp9_temporal_filter_apply_sse4_1(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
-RTCD_EXTERN void (*vp9_temporal_filter_apply)(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
+void vp9_temporal_filter_apply_sse4_1(const uint8_t* frame1,
+                                      unsigned int stride,
+                                      const uint8_t* frame2,
+                                      unsigned int block_width,
+                                      unsigned int block_height,
+                                      int strength,
+                                      int filter_weight,
+                                      uint32_t* accumulator,
+                                      uint16_t* count);
+RTCD_EXTERN void (*vp9_temporal_filter_apply)(const uint8_t* frame1,
+                                              unsigned int stride,
+                                              const uint8_t* frame2,
+                                              unsigned int block_width,
+                                              unsigned int block_height,
+                                              int strength,
+                                              int filter_weight,
+                                              uint32_t* accumulator,
+                                              uint16_t* count);
 
 void vp9_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vp9_block_error = vp9_block_error_c;
-    if (flags & HAS_SSE2) vp9_block_error = vp9_block_error_sse2;
-    if (flags & HAS_AVX2) vp9_block_error = vp9_block_error_avx2;
-    vp9_block_error_fp = vp9_block_error_fp_c;
-    if (flags & HAS_SSE2) vp9_block_error_fp = vp9_block_error_fp_sse2;
-    vp9_denoiser_filter = vp9_denoiser_filter_c;
-    if (flags & HAS_SSE2) vp9_denoiser_filter = vp9_denoiser_filter_sse2;
-    vp9_diamond_search_sad = vp9_diamond_search_sad_c;
-    if (flags & HAS_AVX) vp9_diamond_search_sad = vp9_diamond_search_sad_avx;
-    vp9_fdct8x8_quant = vp9_fdct8x8_quant_c;
-    if (flags & HAS_SSSE3) vp9_fdct8x8_quant = vp9_fdct8x8_quant_ssse3;
-    vp9_fht16x16 = vp9_fht16x16_c;
-    if (flags & HAS_SSE2) vp9_fht16x16 = vp9_fht16x16_sse2;
-    vp9_fht4x4 = vp9_fht4x4_c;
-    if (flags & HAS_SSE2) vp9_fht4x4 = vp9_fht4x4_sse2;
-    vp9_fht8x8 = vp9_fht8x8_c;
-    if (flags & HAS_SSE2) vp9_fht8x8 = vp9_fht8x8_sse2;
-    vp9_filter_by_weight16x16 = vp9_filter_by_weight16x16_c;
-    if (flags & HAS_SSE2) vp9_filter_by_weight16x16 = vp9_filter_by_weight16x16_sse2;
-    vp9_filter_by_weight8x8 = vp9_filter_by_weight8x8_c;
-    if (flags & HAS_SSE2) vp9_filter_by_weight8x8 = vp9_filter_by_weight8x8_sse2;
-    vp9_fwht4x4 = vp9_fwht4x4_c;
-    if (flags & HAS_SSE2) vp9_fwht4x4 = vp9_fwht4x4_sse2;
-    vp9_highbd_block_error = vp9_highbd_block_error_c;
-    if (flags & HAS_SSE2) vp9_highbd_block_error = vp9_highbd_block_error_sse2;
-    vp9_iht16x16_256_add = vp9_iht16x16_256_add_c;
-    if (flags & HAS_SSE2) vp9_iht16x16_256_add = vp9_iht16x16_256_add_sse2;
-    vp9_iht4x4_16_add = vp9_iht4x4_16_add_c;
-    if (flags & HAS_SSE2) vp9_iht4x4_16_add = vp9_iht4x4_16_add_sse2;
-    vp9_iht8x8_64_add = vp9_iht8x8_64_add_c;
-    if (flags & HAS_SSE2) vp9_iht8x8_64_add = vp9_iht8x8_64_add_sse2;
-    vp9_quantize_fp = vp9_quantize_fp_c;
-    if (flags & HAS_SSE2) vp9_quantize_fp = vp9_quantize_fp_sse2;
-    vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_c;
-    if (flags & HAS_SSSE3) vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_ssse3;
-    vp9_temporal_filter_apply = vp9_temporal_filter_apply_c;
-    if (flags & HAS_SSE4_1) vp9_temporal_filter_apply = vp9_temporal_filter_apply_sse4_1;
+  vp9_block_error = vp9_block_error_c;
+  if (flags & HAS_SSE2)
+    vp9_block_error = vp9_block_error_sse2;
+  if (flags & HAS_AVX2)
+    vp9_block_error = vp9_block_error_avx2;
+  vp9_block_error_fp = vp9_block_error_fp_c;
+  if (flags & HAS_SSE2)
+    vp9_block_error_fp = vp9_block_error_fp_sse2;
+  vp9_denoiser_filter = vp9_denoiser_filter_c;
+  if (flags & HAS_SSE2)
+    vp9_denoiser_filter = vp9_denoiser_filter_sse2;
+  vp9_diamond_search_sad = vp9_diamond_search_sad_c;
+  if (flags & HAS_AVX)
+    vp9_diamond_search_sad = vp9_diamond_search_sad_avx;
+  vp9_fdct8x8_quant = vp9_fdct8x8_quant_c;
+  if (flags & HAS_SSSE3)
+    vp9_fdct8x8_quant = vp9_fdct8x8_quant_ssse3;
+  vp9_fht16x16 = vp9_fht16x16_c;
+  if (flags & HAS_SSE2)
+    vp9_fht16x16 = vp9_fht16x16_sse2;
+  vp9_fht4x4 = vp9_fht4x4_c;
+  if (flags & HAS_SSE2)
+    vp9_fht4x4 = vp9_fht4x4_sse2;
+  vp9_fht8x8 = vp9_fht8x8_c;
+  if (flags & HAS_SSE2)
+    vp9_fht8x8 = vp9_fht8x8_sse2;
+  vp9_filter_by_weight16x16 = vp9_filter_by_weight16x16_c;
+  if (flags & HAS_SSE2)
+    vp9_filter_by_weight16x16 = vp9_filter_by_weight16x16_sse2;
+  vp9_filter_by_weight8x8 = vp9_filter_by_weight8x8_c;
+  if (flags & HAS_SSE2)
+    vp9_filter_by_weight8x8 = vp9_filter_by_weight8x8_sse2;
+  vp9_fwht4x4 = vp9_fwht4x4_c;
+  if (flags & HAS_SSE2)
+    vp9_fwht4x4 = vp9_fwht4x4_sse2;
+  vp9_highbd_block_error = vp9_highbd_block_error_c;
+  if (flags & HAS_SSE2)
+    vp9_highbd_block_error = vp9_highbd_block_error_sse2;
+  vp9_iht16x16_256_add = vp9_iht16x16_256_add_c;
+  if (flags & HAS_SSE2)
+    vp9_iht16x16_256_add = vp9_iht16x16_256_add_sse2;
+  vp9_iht4x4_16_add = vp9_iht4x4_16_add_c;
+  if (flags & HAS_SSE2)
+    vp9_iht4x4_16_add = vp9_iht4x4_16_add_sse2;
+  vp9_iht8x8_64_add = vp9_iht8x8_64_add_c;
+  if (flags & HAS_SSE2)
+    vp9_iht8x8_64_add = vp9_iht8x8_64_add_sse2;
+  vp9_quantize_fp = vp9_quantize_fp_c;
+  if (flags & HAS_SSE2)
+    vp9_quantize_fp = vp9_quantize_fp_sse2;
+  vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_c;
+  if (flags & HAS_SSSE3)
+    vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_ssse3;
+  vp9_temporal_filter_apply = vp9_temporal_filter_apply_c;
+  if (flags & HAS_SSE4_1)
+    vp9_temporal_filter_apply = vp9_temporal_filter_apply_sse4_1;
 }
 #endif
 

third_party/libvpx/source/config/win/ia32/vpx_config.asm

diff --git a/third_party/libvpx/source/config/win/ia32/vpx_config.asm b/third_party/libvpx/source/config/win/ia32/vpx_config.asm
index f917264f..6690eb4c 100644
--- a/third_party/libvpx/source/config/win/ia32/vpx_config.asm
+++ b/third_party/libvpx/source/config/win/ia32/vpx_config.asm
@@ -18,6 +18,7 @@
 %define HAVE_AVX 1
 %define HAVE_AVX2 1
 %define HAVE_VSX 0
+%define HAVE_MMI 0
 %define HAVE_VPX_PORTS 1
 %define HAVE_PTHREAD_H 0
 %define HAVE_UNISTD_H 0

third_party/libvpx/source/config/win/ia32/vpx_config.h

diff --git a/third_party/libvpx/source/config/win/ia32/vpx_config.h b/third_party/libvpx/source/config/win/ia32/vpx_config.h
index a2476d0..898acf1 100644
--- a/third_party/libvpx/source/config/win/ia32/vpx_config.h
+++ b/third_party/libvpx/source/config/win/ia32/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 1
 #define HAVE_AVX2 1
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 0
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/win/ia32/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/win/ia32/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/win/ia32/vpx_dsp_rtcd.h
index 58cad7f6..b463d4b37 100644
--- a/third_party/libvpx/source/config/win/ia32/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/win/ia32/vpx_dsp_rtcd.h
@@ -14,2807 +14,9640 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
-unsigned int vpx_avg_4x4_sse2(const uint8_t *, int p);
-RTCD_EXTERN unsigned int (*vpx_avg_4x4)(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
+unsigned int vpx_avg_4x4_sse2(const uint8_t*, int p);
+RTCD_EXTERN unsigned int (*vpx_avg_4x4)(const uint8_t*, int p);
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
-unsigned int vpx_avg_8x8_sse2(const uint8_t *, int p);
-RTCD_EXTERN unsigned int (*vpx_avg_8x8)(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
+unsigned int vpx_avg_8x8_sse2(const uint8_t*, int p);
+RTCD_EXTERN unsigned int (*vpx_avg_8x8)(const uint8_t*, int p);
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-void vpx_comp_avg_pred_sse2(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-RTCD_EXTERN void (*vpx_comp_avg_pred)(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
+void vpx_comp_avg_pred_sse2(uint8_t* comp_pred,
+                            const uint8_t* pred,
+                            int width,
+                            int height,
+                            const uint8_t* ref,
+                            int ref_stride);
+RTCD_EXTERN void (*vpx_comp_avg_pred)(uint8_t* comp_pred,
+                                      const uint8_t* pred,
+                                      int width,
+                                      int height,
+                                      const uint8_t* ref,
+                                      int ref_stride);
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_convolve8_sse2(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve8_ssse3(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avx2(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+RTCD_EXTERN void (*vpx_convolve8)(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avg_sse2(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
+void vpx_convolve8_avg_ssse3(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+RTCD_EXTERN void (*vpx_convolve8_avg)(const uint8_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h);
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg_horiz)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_avg_horiz_sse2(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
+void vpx_convolve8_avg_horiz_ssse3(const uint8_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h);
+RTCD_EXTERN void (*vpx_convolve8_avg_horiz)(const uint8_t* src,
+                                            ptrdiff_t src_stride,
+                                            uint8_t* dst,
+                                            ptrdiff_t dst_stride,
+                                            const int16_t* filter_x,
+                                            int x_step_q4,
+                                            const int16_t* filter_y,
+                                            int y_step_q4,
+                                            int w,
+                                            int h);
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg_vert)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_avg_vert_sse2(const uint8_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h);
+void vpx_convolve8_avg_vert_ssse3(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
+RTCD_EXTERN void (*vpx_convolve8_avg_vert)(const uint8_t* src,
+                                           ptrdiff_t src_stride,
+                                           uint8_t* dst,
+                                           ptrdiff_t dst_stride,
+                                           const int16_t* filter_x,
+                                           int x_step_q4,
+                                           const int16_t* filter_y,
+                                           int y_step_q4,
+                                           int w,
+                                           int h);
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_horiz)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+void vpx_convolve8_horiz_sse2(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_horiz_ssse3(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_horiz_avx2(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+RTCD_EXTERN void (*vpx_convolve8_horiz)(const uint8_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint8_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h);
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_vert)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
+void vpx_convolve8_vert_sse2(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+void vpx_convolve8_vert_ssse3(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_vert_avx2(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+RTCD_EXTERN void (*vpx_convolve8_vert)(const uint8_t* src,
+                                       ptrdiff_t src_stride,
+                                       uint8_t* dst,
+                                       ptrdiff_t dst_stride,
+                                       const int16_t* filter_x,
+                                       int x_step_q4,
+                                       const int16_t* filter_y,
+                                       int y_step_q4,
+                                       int w,
+                                       int h);
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_avg_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve_avg)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve_avg_sse2(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+RTCD_EXTERN void (*vpx_convolve_avg)(const uint8_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint8_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h);
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_copy_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve_copy)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve_copy_sse2(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
+RTCD_EXTERN void (*vpx_convolve_copy)(const uint8_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h);
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_c
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_c
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_c
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_c
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d153_predictor_16x16_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_16x16)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d153_predictor_32x32_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_32x32)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_4x4_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d153_predictor_4x4_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_4x4)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d153_predictor_8x8_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_8x8)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d207_predictor_16x16_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_16x16)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d207_predictor_32x32_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_32x32)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d207_predictor_4x4_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_4x4)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d207_predictor_8x8_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_8x8)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_16x16_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_16x16)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_32x32_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_32x32)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_4x4_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_4x4)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_8x8_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_8x8)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d63_predictor_16x16_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_16x16)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d63_predictor_32x32_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_32x32)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_4x4_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d63_predictor_4x4_ssse3(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_4x4)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d63_predictor_8x8_ssse3(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_8x8)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_16x16_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_16x16)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_32x32_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_32x32)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_4x4_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_4x4)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_128_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_8x8_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_128_predictor_8x8)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_16x16_sse2(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_16x16)(uint8_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint8_t* above,
+                                                const uint8_t* left);
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_32x32_sse2(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_32x32)(uint8_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint8_t* above,
+                                                const uint8_t* left);
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_4x4_sse2(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_4x4)(uint8_t* dst,
+                                              ptrdiff_t y_stride,
+                                              const uint8_t* above,
+                                              const uint8_t* left);
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_left_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_8x8_sse2(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_left_predictor_8x8)(uint8_t* dst,
+                                              ptrdiff_t y_stride,
+                                              const uint8_t* above,
+                                              const uint8_t* left);
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_16x16_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_16x16)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_32x32_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_32x32)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_4x4_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_4x4)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_8x8_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_predictor_8x8)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_16x16_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_16x16)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_32x32_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_32x32)(uint8_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint8_t* above,
+                                               const uint8_t* left);
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_4x4_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_4x4)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_dc_top_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_8x8_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_dc_top_predictor_8x8)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct16x16)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct16x16)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_1_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct16x16_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_1_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct16x16_1)(const int16_t* input,
+                                    tran_low_t* output,
+                                    int stride);
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct32x32)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct32x32)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_1_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct32x32_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_1_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct32x32_1)(const int16_t* input,
+                                    tran_low_t* output,
+                                    int stride);
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_rd_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct32x32_rd)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_rd_sse2(const int16_t* input,
+                           tran_low_t* output,
+                           int stride);
+RTCD_EXTERN void (*vpx_fdct32x32_rd)(const int16_t* input,
+                                     tran_low_t* output,
+                                     int stride);
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct4x4)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct4x4)(const int16_t* input,
+                                tran_low_t* output,
+                                int stride);
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_1_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct4x4_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_1_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct4x4_1)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct8x8)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct8x8)(const int16_t* input,
+                                tran_low_t* output,
+                                int stride);
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_1_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_fdct8x8_1)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_1_sse2(const int16_t* input, tran_low_t* output, int stride);
+RTCD_EXTERN void (*vpx_fdct8x8_1)(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-RTCD_EXTERN void (*vpx_get16x16var)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
+void vpx_get16x16var_sse2(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
+void vpx_get16x16var_avx2(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
+RTCD_EXTERN void (*vpx_get16x16var)(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse,
+                                    int* sum);
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_c
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get8x8var_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-RTCD_EXTERN void (*vpx_get8x8var)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
+void vpx_get8x8var_sse2(const uint8_t* src_ptr,
+                        int source_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        unsigned int* sse,
+                        int* sum);
+RTCD_EXTERN void (*vpx_get8x8var)(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse,
+                                  int* sum);
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
-unsigned int vpx_get_mb_ss_sse2(const int16_t *);
-RTCD_EXTERN unsigned int (*vpx_get_mb_ss)(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
+unsigned int vpx_get_mb_ss_sse2(const int16_t*);
+RTCD_EXTERN unsigned int (*vpx_get_mb_ss)(const int16_t*);
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_16x16_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_16x16)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_32x32_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_32x32)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_4x4_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_4x4)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_h_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_8x8_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_h_predictor_8x8)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_16x16_sse2(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-RTCD_EXTERN void (*vpx_hadamard_16x16)(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          tran_low_t* coeff);
+void vpx_hadamard_16x16_sse2(const int16_t* src_diff,
+                             int src_stride,
+                             tran_low_t* coeff);
+RTCD_EXTERN void (*vpx_hadamard_16x16)(const int16_t* src_diff,
+                                       int src_stride,
+                                       tran_low_t* coeff);
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_8x8_sse2(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-RTCD_EXTERN void (*vpx_hadamard_8x8)(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        tran_low_t* coeff);
+void vpx_hadamard_8x8_sse2(const int16_t* src_diff,
+                           int src_stride,
+                           tran_low_t* coeff);
+RTCD_EXTERN void (*vpx_hadamard_8x8)(const int16_t* src_diff,
+                                     int src_stride,
+                                     tran_low_t* coeff);
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_highbd_10_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_10_get16x16var vpx_highbd_10_get16x16var_c
 
-void vpx_highbd_10_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_10_get8x8var vpx_highbd_10_get8x8var_c
 
-unsigned int vpx_highbd_10_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+unsigned int vpx_highbd_10_mse16x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_mse16x16)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   const uint8_t* ref_ptr,
+                                                   int recon_stride,
+                                                   unsigned int* sse);
 
-unsigned int vpx_highbd_10_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse16x8 vpx_highbd_10_mse16x8_c
 
-unsigned int vpx_highbd_10_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse8x16 vpx_highbd_10_mse8x16_c
 
-unsigned int vpx_highbd_10_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_mse8x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
+unsigned int vpx_highbd_10_mse8x8_sse2(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_mse8x8)(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 const uint8_t* ref_ptr,
+                                                 int recon_stride,
+                                                 unsigned int* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x4 vpx_highbd_10_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x4 \
+  vpx_highbd_10_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x8 vpx_highbd_10_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x8 \
+  vpx_highbd_10_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x4 vpx_highbd_10_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x4 \
+  vpx_highbd_10_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x8 vpx_highbd_10_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x8 \
+  vpx_highbd_10_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_10_sub_pixel_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-unsigned int vpx_highbd_10_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x16)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance16x8)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x16)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance32x64)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x4 vpx_highbd_10_variance4x4_c
 
-unsigned int vpx_highbd_10_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x8 vpx_highbd_10_variance4x8_c
 
-unsigned int vpx_highbd_10_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance64x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance64x64)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance8x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_10_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance8x16)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_10_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance8x4 vpx_highbd_10_variance8x4_c
 
-unsigned int vpx_highbd_10_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_10_variance8x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_10_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_10_variance8x8)(const uint8_t* src_ptr,
+                                                      int source_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride,
+                                                      unsigned int* sse);
 
-void vpx_highbd_12_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_12_get16x16var vpx_highbd_12_get16x16var_c
 
-void vpx_highbd_12_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_12_get8x8var vpx_highbd_12_get8x8var_c
 
-unsigned int vpx_highbd_12_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+unsigned int vpx_highbd_12_mse16x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_mse16x16)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   const uint8_t* ref_ptr,
+                                                   int recon_stride,
+                                                   unsigned int* sse);
 
-unsigned int vpx_highbd_12_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse16x8 vpx_highbd_12_mse16x8_c
 
-unsigned int vpx_highbd_12_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse8x16 vpx_highbd_12_mse8x16_c
 
-unsigned int vpx_highbd_12_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_mse8x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
+unsigned int vpx_highbd_12_mse8x8_sse2(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_mse8x8)(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 const uint8_t* ref_ptr,
+                                                 int recon_stride,
+                                                 unsigned int* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x4 vpx_highbd_12_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x4 \
+  vpx_highbd_12_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x8 vpx_highbd_12_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x8 \
+  vpx_highbd_12_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x4 vpx_highbd_12_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x4 \
+  vpx_highbd_12_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x8 vpx_highbd_12_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x8 \
+  vpx_highbd_12_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_12_sub_pixel_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-unsigned int vpx_highbd_12_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x16)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance16x8)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x16)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance32x64)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x4 vpx_highbd_12_variance4x4_c
 
-unsigned int vpx_highbd_12_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x8 vpx_highbd_12_variance4x8_c
 
-unsigned int vpx_highbd_12_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance64x32)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance64x64)(const uint8_t* src_ptr,
+                                                        int source_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride,
+                                                        unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance8x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_12_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance8x16)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_12_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance8x4 vpx_highbd_12_variance8x4_c
 
-unsigned int vpx_highbd_12_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_12_variance8x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_12_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_12_variance8x8)(const uint8_t* src_ptr,
+                                                      int source_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride,
+                                                      unsigned int* sse);
 
-void vpx_highbd_8_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get16x16var_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse,
+                                int* sum);
 #define vpx_highbd_8_get16x16var vpx_highbd_8_get16x16var_c
 
-void vpx_highbd_8_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get8x8var_c(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              unsigned int* sse,
+                              int* sum);
 #define vpx_highbd_8_get8x8var vpx_highbd_8_get8x8var_c
 
-unsigned int vpx_highbd_8_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
+unsigned int vpx_highbd_8_mse16x16_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int recon_stride,
+                                        unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_mse16x16)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  const uint8_t* ref_ptr,
+                                                  int recon_stride,
+                                                  unsigned int* sse);
 
-unsigned int vpx_highbd_8_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse16x8 vpx_highbd_8_mse16x8_c
 
-unsigned int vpx_highbd_8_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x16_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse8x16 vpx_highbd_8_mse8x16_c
 
-unsigned int vpx_highbd_8_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_mse8x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x8_c(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int recon_stride,
+                                   unsigned int* sse);
+unsigned int vpx_highbd_8_mse8x8_sse2(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_mse8x8)(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                const uint8_t* ref_ptr,
+                                                int recon_stride,
+                                                unsigned int* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x4 vpx_highbd_8_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x4 \
+  vpx_highbd_8_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x8 vpx_highbd_8_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x8 \
+  vpx_highbd_8_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x4 vpx_highbd_8_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x8 vpx_highbd_8_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_highbd_8_sub_pixel_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse);
 
-unsigned int vpx_highbd_8_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x16)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x32)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance16x8)(const uint8_t* src_ptr,
+                                                      int source_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride,
+                                                      unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x16)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x32)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x64_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance32x64)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x4 vpx_highbd_8_variance4x4_c
 
-unsigned int vpx_highbd_8_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x8 vpx_highbd_8_variance4x8_c
 
-unsigned int vpx_highbd_8_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance64x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance64x32)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance64x64_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance64x64)(const uint8_t* src_ptr,
+                                                       int source_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride,
+                                                       unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance8x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x16_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_8_variance8x16_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance8x16)(const uint8_t* src_ptr,
+                                                      int source_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride,
+                                                      unsigned int* sse);
 
-unsigned int vpx_highbd_8_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance8x4 vpx_highbd_8_variance8x4_c
 
-unsigned int vpx_highbd_8_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_highbd_8_variance8x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
+unsigned int vpx_highbd_8_variance8x8_sse2(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_highbd_8_variance8x8)(const uint8_t* src_ptr,
+                                                     int source_stride,
+                                                     const uint8_t* ref_ptr,
+                                                     int ref_stride,
+                                                     unsigned int* sse);
 
-unsigned int vpx_highbd_avg_4x4_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_4x4_c(const uint8_t*, int p);
 #define vpx_highbd_avg_4x4 vpx_highbd_avg_4x4_c
 
-unsigned int vpx_highbd_avg_8x8_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_8x8_c(const uint8_t*, int p);
 #define vpx_highbd_avg_8x8 vpx_highbd_avg_8x8_c
 
-void vpx_highbd_comp_avg_pred_c(uint16_t *comp_pred, const uint8_t *pred8, int width, int height, const uint8_t *ref8, int ref_stride);
+void vpx_highbd_comp_avg_pred_c(uint16_t* comp_pred,
+                                const uint8_t* pred8,
+                                int width,
+                                int height,
+                                const uint8_t* ref8,
+                                int ref_stride);
 #define vpx_highbd_comp_avg_pred vpx_highbd_comp_avg_pred_c
 
-void vpx_highbd_convolve8_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_c(const uint16_t* src,
+                            ptrdiff_t src_stride,
+                            uint16_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h,
+                            int bps);
+void vpx_highbd_convolve8_avx2(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8)(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
 
-void vpx_highbd_convolve8_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
+void vpx_highbd_convolve8_avg_avx2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg)(const uint16_t* src,
+                                             ptrdiff_t src_stride,
+                                             uint16_t* dst,
+                                             ptrdiff_t dst_stride,
+                                             const int16_t* filter_x,
+                                             int x_step_q4,
+                                             const int16_t* filter_y,
+                                             int y_step_q4,
+                                             int w,
+                                             int h,
+                                             int bps);
 
-void vpx_highbd_convolve8_avg_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_horiz_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg_horiz)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_horiz_c(const uint16_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint16_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h,
+                                      int bps);
+void vpx_highbd_convolve8_avg_horiz_avx2(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg_horiz)(const uint16_t* src,
+                                                   ptrdiff_t src_stride,
+                                                   uint16_t* dst,
+                                                   ptrdiff_t dst_stride,
+                                                   const int16_t* filter_x,
+                                                   int x_step_q4,
+                                                   const int16_t* filter_y,
+                                                   int y_step_q4,
+                                                   int w,
+                                                   int h,
+                                                   int bps);
 
-void vpx_highbd_convolve8_avg_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_vert_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg_vert)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_vert_c(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+void vpx_highbd_convolve8_avg_vert_avx2(const uint16_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint16_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h,
+                                        int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg_vert)(const uint16_t* src,
+                                                  ptrdiff_t src_stride,
+                                                  uint16_t* dst,
+                                                  ptrdiff_t dst_stride,
+                                                  const int16_t* filter_x,
+                                                  int x_step_q4,
+                                                  const int16_t* filter_y,
+                                                  int y_step_q4,
+                                                  int w,
+                                                  int h,
+                                                  int bps);
 
-void vpx_highbd_convolve8_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_horiz_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_horiz)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_horiz_c(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+void vpx_highbd_convolve8_horiz_avx2(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_horiz)(const uint16_t* src,
+                                               ptrdiff_t src_stride,
+                                               uint16_t* dst,
+                                               ptrdiff_t dst_stride,
+                                               const int16_t* filter_x,
+                                               int x_step_q4,
+                                               const int16_t* filter_y,
+                                               int y_step_q4,
+                                               int w,
+                                               int h,
+                                               int bps);
 
-void vpx_highbd_convolve8_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_vert_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_vert)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_vert_c(const uint16_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint16_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h,
+                                 int bps);
+void vpx_highbd_convolve8_vert_avx2(const uint16_t* src,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst,
+                                    ptrdiff_t dst_stride,
+                                    const int16_t* filter_x,
+                                    int x_step_q4,
+                                    const int16_t* filter_y,
+                                    int y_step_q4,
+                                    int w,
+                                    int h,
+                                    int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_vert)(const uint16_t* src,
+                                              ptrdiff_t src_stride,
+                                              uint16_t* dst,
+                                              ptrdiff_t dst_stride,
+                                              const int16_t* filter_x,
+                                              int x_step_q4,
+                                              const int16_t* filter_y,
+                                              int y_step_q4,
+                                              int w,
+                                              int h,
+                                              int bps);
 
-void vpx_highbd_convolve_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_avg_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_avg_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve_avg)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_avg_c(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+void vpx_highbd_convolve_avg_sse2(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+void vpx_highbd_convolve_avg_avx2(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve_avg)(const uint16_t* src,
+                                            ptrdiff_t src_stride,
+                                            uint16_t* dst,
+                                            ptrdiff_t dst_stride,
+                                            const int16_t* filter_x,
+                                            int x_step_q4,
+                                            const int16_t* filter_y,
+                                            int y_step_q4,
+                                            int w,
+                                            int h,
+                                            int bps);
 
-void vpx_highbd_convolve_copy_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_copy_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_copy_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve_copy)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_copy_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
+void vpx_highbd_convolve_copy_sse2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+void vpx_highbd_convolve_copy_avx2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve_copy)(const uint16_t* src,
+                                             ptrdiff_t src_stride,
+                                             uint16_t* dst,
+                                             ptrdiff_t dst_stride,
+                                             const int16_t* filter_x,
+                                             int x_step_q4,
+                                             const int16_t* filter_y,
+                                             int y_step_q4,
+                                             int w,
+                                             int h,
+                                             int bps);
 
-void vpx_highbd_d117_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_16x16 vpx_highbd_d117_predictor_16x16_c
 
-void vpx_highbd_d117_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_32x32 vpx_highbd_d117_predictor_32x32_c
 
-void vpx_highbd_d117_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_4x4 vpx_highbd_d117_predictor_4x4_c
 
-void vpx_highbd_d117_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_8x8 vpx_highbd_d117_predictor_8x8_c
 
-void vpx_highbd_d135_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_16x16 vpx_highbd_d135_predictor_16x16_c
 
-void vpx_highbd_d135_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_32x32 vpx_highbd_d135_predictor_32x32_c
 
-void vpx_highbd_d135_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_4x4 vpx_highbd_d135_predictor_4x4_c
 
-void vpx_highbd_d135_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_8x8 vpx_highbd_d135_predictor_8x8_c
 
-void vpx_highbd_d153_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_16x16 vpx_highbd_d153_predictor_16x16_c
 
-void vpx_highbd_d153_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_32x32 vpx_highbd_d153_predictor_32x32_c
 
-void vpx_highbd_d153_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_4x4 vpx_highbd_d153_predictor_4x4_c
 
-void vpx_highbd_d153_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_8x8 vpx_highbd_d153_predictor_8x8_c
 
-void vpx_highbd_d207_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_16x16 vpx_highbd_d207_predictor_16x16_c
 
-void vpx_highbd_d207_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_32x32 vpx_highbd_d207_predictor_32x32_c
 
-void vpx_highbd_d207_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_4x4 vpx_highbd_d207_predictor_4x4_c
 
-void vpx_highbd_d207_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_8x8 vpx_highbd_d207_predictor_8x8_c
 
-void vpx_highbd_d45_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_16x16 vpx_highbd_d45_predictor_16x16_c
 
-void vpx_highbd_d45_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_32x32 vpx_highbd_d45_predictor_32x32_c
 
-void vpx_highbd_d45_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_4x4 vpx_highbd_d45_predictor_4x4_c
 
-void vpx_highbd_d45_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_8x8 vpx_highbd_d45_predictor_8x8_c
 
-void vpx_highbd_d63_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_16x16 vpx_highbd_d63_predictor_16x16_c
 
-void vpx_highbd_d63_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_32x32 vpx_highbd_d63_predictor_32x32_c
 
-void vpx_highbd_d63_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_4x4 vpx_highbd_d63_predictor_4x4_c
 
-void vpx_highbd_d63_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_8x8 vpx_highbd_d63_predictor_8x8_c
 
-void vpx_highbd_dc_128_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_16x16 vpx_highbd_dc_128_predictor_16x16_c
 
-void vpx_highbd_dc_128_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_32x32 vpx_highbd_dc_128_predictor_32x32_c
 
-void vpx_highbd_dc_128_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_4x4 vpx_highbd_dc_128_predictor_4x4_c
 
-void vpx_highbd_dc_128_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_8x8 vpx_highbd_dc_128_predictor_8x8_c
 
-void vpx_highbd_dc_left_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_16x16_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_16x16 vpx_highbd_dc_left_predictor_16x16_c
 
-void vpx_highbd_dc_left_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_32x32_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_32x32 vpx_highbd_dc_left_predictor_32x32_c
 
-void vpx_highbd_dc_left_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_4x4_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_4x4 vpx_highbd_dc_left_predictor_4x4_c
 
-void vpx_highbd_dc_left_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_8x8_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_8x8 vpx_highbd_dc_left_predictor_8x8_c
 
-void vpx_highbd_dc_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_dc_predictor_16x16)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_dc_predictor_16x16_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
+RTCD_EXTERN void (*vpx_highbd_dc_predictor_16x16)(uint16_t* dst,
+                                                  ptrdiff_t y_stride,
+                                                  const uint16_t* above,
+                                                  const uint16_t* left,
+                                                  int bd);
 
-void vpx_highbd_dc_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_dc_predictor_32x32)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_dc_predictor_32x32_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
+RTCD_EXTERN void (*vpx_highbd_dc_predictor_32x32)(uint16_t* dst,
+                                                  ptrdiff_t y_stride,
+                                                  const uint16_t* above,
+                                                  const uint16_t* left,
+                                                  int bd);
 
-void vpx_highbd_dc_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_dc_predictor_4x4)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_dc_predictor_4x4_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_dc_predictor_4x4)(uint16_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint16_t* above,
+                                                const uint16_t* left,
+                                                int bd);
 
-void vpx_highbd_dc_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_dc_predictor_8x8)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_dc_predictor_8x8_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_dc_predictor_8x8)(uint16_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint16_t* above,
+                                                const uint16_t* left,
+                                                int bd);
 
-void vpx_highbd_dc_top_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_16x16 vpx_highbd_dc_top_predictor_16x16_c
 
-void vpx_highbd_dc_top_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_32x32 vpx_highbd_dc_top_predictor_32x32_c
 
-void vpx_highbd_dc_top_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_4x4 vpx_highbd_dc_top_predictor_4x4_c
 
-void vpx_highbd_dc_top_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_8x8 vpx_highbd_dc_top_predictor_8x8_c
 
-void vpx_highbd_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct16x16_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct16x16)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
+void vpx_highbd_fdct16x16_sse2(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct16x16)(const int16_t* input,
+                                         tran_low_t* output,
+                                         int stride);
 
-void vpx_highbd_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct16x16_1 vpx_highbd_fdct16x16_1_c
 
-void vpx_highbd_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct32x32_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct32x32)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
+void vpx_highbd_fdct32x32_sse2(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct32x32)(const int16_t* input,
+                                         tran_low_t* output,
+                                         int stride);
 
-void vpx_highbd_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct32x32_1 vpx_highbd_fdct32x32_1_c
 
-void vpx_highbd_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct32x32_rd_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct32x32_rd)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_rd_c(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
+void vpx_highbd_fdct32x32_rd_sse2(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct32x32_rd)(const int16_t* input,
+                                            tran_low_t* output,
+                                            int stride);
 
-void vpx_highbd_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct4x4)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_highbd_fdct4x4_sse2(const int16_t* input,
+                             tran_low_t* output,
+                             int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct4x4)(const int16_t* input,
+                                       tran_low_t* output,
+                                       int stride);
 
-void vpx_highbd_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct8x8_sse2(const int16_t *input, tran_low_t *output, int stride);
-RTCD_EXTERN void (*vpx_highbd_fdct8x8)(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_highbd_fdct8x8_sse2(const int16_t* input,
+                             tran_low_t* output,
+                             int stride);
+RTCD_EXTERN void (*vpx_highbd_fdct8x8)(const int16_t* input,
+                                       tran_low_t* output,
+                                       int stride);
 
-void vpx_highbd_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_1_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
 #define vpx_highbd_fdct8x8_1 vpx_highbd_fdct8x8_1_c
 
-void vpx_highbd_h_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_16x16 vpx_highbd_h_predictor_16x16_c
 
-void vpx_highbd_h_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_32x32 vpx_highbd_h_predictor_32x32_c
 
-void vpx_highbd_h_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_4x4 vpx_highbd_h_predictor_4x4_c
 
-void vpx_highbd_h_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_8x8 vpx_highbd_h_predictor_8x8_c
 
-void vpx_highbd_idct16x16_10_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_10_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct16x16_10_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_10_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+void vpx_highbd_idct16x16_10_add_sse2(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct16x16_10_add)(const tran_low_t* input,
+                                                uint16_t* dest,
+                                                int stride,
+                                                int bd);
 
-void vpx_highbd_idct16x16_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct16x16_1_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
+void vpx_highbd_idct16x16_1_add_sse2(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_idct16x16_1_add)(const tran_low_t* input,
+                                               uint16_t* dest,
+                                               int stride,
+                                               int bd);
 
-void vpx_highbd_idct16x16_256_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct16x16_256_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_256_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t* input,
+                                       uint16_t* dest,
+                                       int stride,
+                                       int bd);
+RTCD_EXTERN void (*vpx_highbd_idct16x16_256_add)(const tran_low_t* input,
+                                                 uint16_t* dest,
+                                                 int stride,
+                                                 int bd);
 
-void vpx_highbd_idct16x16_38_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct16x16_38_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_38_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+void vpx_highbd_idct16x16_38_add_sse2(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct16x16_38_add)(const tran_low_t* input,
+                                                uint16_t* dest,
+                                                int stride,
+                                                int bd);
 
-void vpx_highbd_idct32x32_1024_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1024_add_c(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
 #define vpx_highbd_idct32x32_1024_add vpx_highbd_idct32x32_1024_add_c
 
-void vpx_highbd_idct32x32_135_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_135_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
 #define vpx_highbd_idct32x32_135_add vpx_highbd_idct32x32_135_add_c
 
-void vpx_highbd_idct32x32_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct32x32_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct32x32_1_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
+void vpx_highbd_idct32x32_1_add_sse2(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_idct32x32_1_add)(const tran_low_t* input,
+                                               uint16_t* dest,
+                                               int stride,
+                                               int bd);
 
-void vpx_highbd_idct32x32_34_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_34_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct32x32_34_add vpx_highbd_idct32x32_34_add_c
 
-void vpx_highbd_idct4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_16_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_16_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct4x4_16_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct4x4_16_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct4x4_16_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct4x4_16_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_idct4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct4x4_1_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
+void vpx_highbd_idct4x4_1_add_sse2(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+RTCD_EXTERN void (*vpx_highbd_idct4x4_1_add)(const tran_low_t* input,
+                                             uint16_t* dest,
+                                             int stride,
+                                             int bd);
 
-void vpx_highbd_idct8x8_12_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_12_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_12_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_12_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_12_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct8x8_12_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct8x8_12_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_12_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_idct8x8_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_1_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
+void vpx_highbd_idct8x8_1_add_sse2(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_1_add)(const tran_low_t* input,
+                                             uint16_t* dest,
+                                             int stride,
+                                             int bd);
 
-void vpx_highbd_idct8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_64_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_64_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_64_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_64_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct8x8_64_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct8x8_64_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_64_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_iwht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
 #define vpx_highbd_iwht4x4_16_add vpx_highbd_iwht4x4_16_add_c
 
-void vpx_highbd_iwht4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
 #define vpx_highbd_iwht4x4_1_add vpx_highbd_iwht4x4_1_add_c
 
-void vpx_highbd_lpf_horizontal_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_16_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_16)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_c(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
+void vpx_highbd_lpf_horizontal_16_sse2(uint16_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh,
+                                       int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_16)(uint16_t* s,
+                                                 int pitch,
+                                                 const uint8_t* blimit,
+                                                 const uint8_t* limit,
+                                                 const uint8_t* thresh,
+                                                 int bd);
 
-void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_16_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_16_dual)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh,
+                                         int bd);
+void vpx_highbd_lpf_horizontal_16_dual_sse2(uint16_t* s,
+                                            int pitch,
+                                            const uint8_t* blimit,
+                                            const uint8_t* limit,
+                                            const uint8_t* thresh,
+                                            int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_16_dual)(uint16_t* s,
+                                                      int pitch,
+                                                      const uint8_t* blimit,
+                                                      const uint8_t* limit,
+                                                      const uint8_t* thresh,
+                                                      int bd);
 
-void vpx_highbd_lpf_horizontal_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_4_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_4)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_4_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
+void vpx_highbd_lpf_horizontal_4_sse2(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit,
+                                      const uint8_t* limit,
+                                      const uint8_t* thresh,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_4)(uint16_t* s,
+                                                int pitch,
+                                                const uint8_t* blimit,
+                                                const uint8_t* limit,
+                                                const uint8_t* thresh,
+                                                int bd);
 
-void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_horizontal_4_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_4_dual)(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
+void vpx_highbd_lpf_horizontal_4_dual_sse2(uint16_t* s,
+                                           int pitch,
+                                           const uint8_t* blimit0,
+                                           const uint8_t* limit0,
+                                           const uint8_t* thresh0,
+                                           const uint8_t* blimit1,
+                                           const uint8_t* limit1,
+                                           const uint8_t* thresh1,
+                                           int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_4_dual)(uint16_t* s,
+                                                     int pitch,
+                                                     const uint8_t* blimit0,
+                                                     const uint8_t* limit0,
+                                                     const uint8_t* thresh0,
+                                                     const uint8_t* blimit1,
+                                                     const uint8_t* limit1,
+                                                     const uint8_t* thresh1,
+                                                     int bd);
 
-void vpx_highbd_lpf_horizontal_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_8_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_8)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_8_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
+void vpx_highbd_lpf_horizontal_8_sse2(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit,
+                                      const uint8_t* limit,
+                                      const uint8_t* thresh,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_8)(uint16_t* s,
+                                                int pitch,
+                                                const uint8_t* blimit,
+                                                const uint8_t* limit,
+                                                const uint8_t* thresh,
+                                                int bd);
 
-void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_horizontal_8_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_8_dual)(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
+void vpx_highbd_lpf_horizontal_8_dual_sse2(uint16_t* s,
+                                           int pitch,
+                                           const uint8_t* blimit0,
+                                           const uint8_t* limit0,
+                                           const uint8_t* thresh0,
+                                           const uint8_t* blimit1,
+                                           const uint8_t* limit1,
+                                           const uint8_t* thresh1,
+                                           int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_horizontal_8_dual)(uint16_t* s,
+                                                     int pitch,
+                                                     const uint8_t* blimit0,
+                                                     const uint8_t* limit0,
+                                                     const uint8_t* thresh0,
+                                                     const uint8_t* blimit1,
+                                                     const uint8_t* limit1,
+                                                     const uint8_t* thresh1,
+                                                     int bd);
 
-void vpx_highbd_lpf_vertical_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_16_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_16)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_c(uint16_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh,
+                                  int bd);
+void vpx_highbd_lpf_vertical_16_sse2(uint16_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_16)(uint16_t* s,
+                                               int pitch,
+                                               const uint8_t* blimit,
+                                               const uint8_t* limit,
+                                               const uint8_t* thresh,
+                                               int bd);
 
-void vpx_highbd_lpf_vertical_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_16_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_16_dual)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_dual_c(uint16_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh,
+                                       int bd);
+void vpx_highbd_lpf_vertical_16_dual_sse2(uint16_t* s,
+                                          int pitch,
+                                          const uint8_t* blimit,
+                                          const uint8_t* limit,
+                                          const uint8_t* thresh,
+                                          int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_16_dual)(uint16_t* s,
+                                                    int pitch,
+                                                    const uint8_t* blimit,
+                                                    const uint8_t* limit,
+                                                    const uint8_t* thresh,
+                                                    int bd);
 
-void vpx_highbd_lpf_vertical_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_4_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_4)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_4_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
+void vpx_highbd_lpf_vertical_4_sse2(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_4)(uint16_t* s,
+                                              int pitch,
+                                              const uint8_t* blimit,
+                                              const uint8_t* limit,
+                                              const uint8_t* thresh,
+                                              int bd);
 
-void vpx_highbd_lpf_vertical_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_vertical_4_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_4_dual)(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_4_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
+void vpx_highbd_lpf_vertical_4_dual_sse2(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit0,
+                                         const uint8_t* limit0,
+                                         const uint8_t* thresh0,
+                                         const uint8_t* blimit1,
+                                         const uint8_t* limit1,
+                                         const uint8_t* thresh1,
+                                         int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_4_dual)(uint16_t* s,
+                                                   int pitch,
+                                                   const uint8_t* blimit0,
+                                                   const uint8_t* limit0,
+                                                   const uint8_t* thresh0,
+                                                   const uint8_t* blimit1,
+                                                   const uint8_t* limit1,
+                                                   const uint8_t* thresh1,
+                                                   int bd);
 
-void vpx_highbd_lpf_vertical_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_8_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_8)(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_8_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
+void vpx_highbd_lpf_vertical_8_sse2(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_8)(uint16_t* s,
+                                              int pitch,
+                                              const uint8_t* blimit,
+                                              const uint8_t* limit,
+                                              const uint8_t* thresh,
+                                              int bd);
 
-void vpx_highbd_lpf_vertical_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_vertical_8_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-RTCD_EXTERN void (*vpx_highbd_lpf_vertical_8_dual)(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_8_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
+void vpx_highbd_lpf_vertical_8_dual_sse2(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit0,
+                                         const uint8_t* limit0,
+                                         const uint8_t* thresh0,
+                                         const uint8_t* blimit1,
+                                         const uint8_t* limit1,
+                                         const uint8_t* thresh1,
+                                         int bd);
+RTCD_EXTERN void (*vpx_highbd_lpf_vertical_8_dual)(uint16_t* s,
+                                                   int pitch,
+                                                   const uint8_t* blimit0,
+                                                   const uint8_t* limit0,
+                                                   const uint8_t* thresh0,
+                                                   const uint8_t* blimit1,
+                                                   const uint8_t* limit1,
+                                                   const uint8_t* thresh1,
+                                                   int bd);
 
-void vpx_highbd_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_highbd_minmax_8x8_c(const uint8_t* s,
+                             int p,
+                             const uint8_t* d,
+                             int dp,
+                             int* min,
+                             int* max);
 #define vpx_highbd_minmax_8x8 vpx_highbd_minmax_8x8_c
 
-void vpx_highbd_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_highbd_quantize_b_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_highbd_quantize_b)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* zbin_ptr,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             const int16_t* quant_shift_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+void vpx_highbd_quantize_b_sse2(const tran_low_t* coeff_ptr,
+                                intptr_t n_coeffs,
+                                int skip_block,
+                                const int16_t* zbin_ptr,
+                                const int16_t* round_ptr,
+                                const int16_t* quant_ptr,
+                                const int16_t* quant_shift_ptr,
+                                tran_low_t* qcoeff_ptr,
+                                tran_low_t* dqcoeff_ptr,
+                                const int16_t* dequant_ptr,
+                                uint16_t* eob_ptr,
+                                const int16_t* scan,
+                                const int16_t* iscan);
+RTCD_EXTERN void (*vpx_highbd_quantize_b)(const tran_low_t* coeff_ptr,
+                                          intptr_t n_coeffs,
+                                          int skip_block,
+                                          const int16_t* zbin_ptr,
+                                          const int16_t* round_ptr,
+                                          const int16_t* quant_ptr,
+                                          const int16_t* quant_shift_ptr,
+                                          tran_low_t* qcoeff_ptr,
+                                          tran_low_t* dqcoeff_ptr,
+                                          const int16_t* dequant_ptr,
+                                          uint16_t* eob_ptr,
+                                          const int16_t* scan,
+                                          const int16_t* iscan);
 
-void vpx_highbd_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_highbd_quantize_b_32x32_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_highbd_quantize_b_32x32)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
+void vpx_highbd_quantize_b_32x32_sse2(const tran_low_t* coeff_ptr,
+                                      intptr_t n_coeffs,
+                                      int skip_block,
+                                      const int16_t* zbin_ptr,
+                                      const int16_t* round_ptr,
+                                      const int16_t* quant_ptr,
+                                      const int16_t* quant_shift_ptr,
+                                      tran_low_t* qcoeff_ptr,
+                                      tran_low_t* dqcoeff_ptr,
+                                      const int16_t* dequant_ptr,
+                                      uint16_t* eob_ptr,
+                                      const int16_t* scan,
+                                      const int16_t* iscan);
+RTCD_EXTERN void (*vpx_highbd_quantize_b_32x32)(const tran_low_t* coeff_ptr,
+                                                intptr_t n_coeffs,
+                                                int skip_block,
+                                                const int16_t* zbin_ptr,
+                                                const int16_t* round_ptr,
+                                                const int16_t* quant_ptr,
+                                                const int16_t* quant_shift_ptr,
+                                                tran_low_t* qcoeff_ptr,
+                                                tran_low_t* dqcoeff_ptr,
+                                                const int16_t* dequant_ptr,
+                                                uint16_t* eob_ptr,
+                                                const int16_t* scan,
+                                                const int16_t* iscan);
 
-unsigned int vpx_highbd_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad16x16_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x16)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x16_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x16_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad16x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad16x16x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad16x16x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad16x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x32)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x32_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad16x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad16x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad16x32x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x8_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int vpx_highbd_sad16x8_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x8)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
 
-unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad16x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x8_avg_sse2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad16x8_avg)(const uint8_t* src_ptr,
+                                                   int src_stride,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   const uint8_t* second_pred);
 
-void vpx_highbd_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad16x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x8x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void vpx_highbd_sad16x8x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad16x8x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x16_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x16)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x16_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x16_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad32x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x16x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad32x16x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x32)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x32_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad32x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad32x32x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x64)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad32x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x64_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad32x64_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad32x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad32x64x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x4 vpx_highbd_sad4x4_c
 
-unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x4_avg vpx_highbd_sad4x4_avg_c
 
-void vpx_highbd_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad4x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad4x4x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad4x4x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad4x4x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x8 vpx_highbd_sad4x8_c
 
-unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x8_avg vpx_highbd_sad4x8_avg_c
 
-void vpx_highbd_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad4x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad4x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad4x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad4x8x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad64x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad64x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad64x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad64x32)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad64x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad64x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad64x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad64x32_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad64x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad64x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad64x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad64x32x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad64x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad64x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad64x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad64x64)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
 
-unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad64x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad64x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad64x64_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad64x64_avg)(const uint8_t* src_ptr,
+                                                    int src_stride,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    const uint8_t* second_pred);
 
-void vpx_highbd_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad64x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad64x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad64x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad64x64x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int vpx_highbd_sad8x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x16)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
 
-unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x16_avg_sse2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x16_avg)(const uint8_t* src_ptr,
+                                                   int src_stride,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   const uint8_t* second_pred);
 
-void vpx_highbd_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad8x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void vpx_highbd_sad8x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad8x16x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x4)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int vpx_highbd_sad8x4_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x4)(const uint8_t* src_ptr,
+                                              int src_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride);
 
-unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x4_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x4_avg_sse2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x4_avg)(const uint8_t* src_ptr,
+                                                  int src_stride,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  const uint8_t* second_pred);
 
-void vpx_highbd_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad8x4x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad8x4x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad8x4x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
 
-unsigned int vpx_highbd_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int vpx_highbd_sad8x8_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x8)(const uint8_t* src_ptr,
+                                              int src_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride);
 
-unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_highbd_sad8x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x8_avg_sse2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_highbd_sad8x8_avg)(const uint8_t* src_ptr,
+                                                  int src_stride,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  const uint8_t* second_pred);
 
-void vpx_highbd_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_highbd_sad8x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad8x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_highbd_sad8x8x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
 
-void vpx_highbd_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride, int bd);
+void vpx_highbd_subtract_block_c(int rows,
+                                 int cols,
+                                 int16_t* diff_ptr,
+                                 ptrdiff_t diff_stride,
+                                 const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 const uint8_t* pred_ptr,
+                                 ptrdiff_t pred_stride,
+                                 int bd);
 #define vpx_highbd_subtract_block vpx_highbd_subtract_block_c
 
-void vpx_highbd_tm_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_tm_predictor_16x16)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_tm_predictor_16x16_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
+RTCD_EXTERN void (*vpx_highbd_tm_predictor_16x16)(uint16_t* dst,
+                                                  ptrdiff_t y_stride,
+                                                  const uint16_t* above,
+                                                  const uint16_t* left,
+                                                  int bd);
 
-void vpx_highbd_tm_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_tm_predictor_32x32)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_tm_predictor_32x32_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
+RTCD_EXTERN void (*vpx_highbd_tm_predictor_32x32)(uint16_t* dst,
+                                                  ptrdiff_t y_stride,
+                                                  const uint16_t* above,
+                                                  const uint16_t* left,
+                                                  int bd);
 
-void vpx_highbd_tm_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_tm_predictor_4x4)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_tm_predictor_4x4_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_tm_predictor_4x4)(uint16_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint16_t* above,
+                                                const uint16_t* left,
+                                                int bd);
 
-void vpx_highbd_tm_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_tm_predictor_8x8)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_tm_predictor_8x8_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_tm_predictor_8x8)(uint16_t* dst,
+                                                ptrdiff_t y_stride,
+                                                const uint16_t* above,
+                                                const uint16_t* left,
+                                                int bd);
 
-void vpx_highbd_v_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_v_predictor_16x16)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
+void vpx_highbd_v_predictor_16x16_sse2(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
+RTCD_EXTERN void (*vpx_highbd_v_predictor_16x16)(uint16_t* dst,
+                                                 ptrdiff_t y_stride,
+                                                 const uint16_t* above,
+                                                 const uint16_t* left,
+                                                 int bd);
 
-void vpx_highbd_v_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_v_predictor_32x32)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
+void vpx_highbd_v_predictor_32x32_sse2(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
+RTCD_EXTERN void (*vpx_highbd_v_predictor_32x32)(uint16_t* dst,
+                                                 ptrdiff_t y_stride,
+                                                 const uint16_t* above,
+                                                 const uint16_t* left,
+                                                 int bd);
 
-void vpx_highbd_v_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_v_predictor_4x4)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
+void vpx_highbd_v_predictor_4x4_sse2(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_v_predictor_4x4)(uint16_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint16_t* above,
+                                               const uint16_t* left,
+                                               int bd);
 
-void vpx_highbd_v_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-RTCD_EXTERN void (*vpx_highbd_v_predictor_8x8)(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
+void vpx_highbd_v_predictor_8x8_sse2(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+RTCD_EXTERN void (*vpx_highbd_v_predictor_8x8)(uint16_t* dst,
+                                               ptrdiff_t y_stride,
+                                               const uint16_t* above,
+                                               const uint16_t* left,
+                                               int bd);
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_10_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_10_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_10_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+RTCD_EXTERN void (*vpx_idct16x16_10_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_1_add_sse2(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+RTCD_EXTERN void (*vpx_idct16x16_1_add)(const tran_low_t* input,
+                                        uint8_t* dest,
+                                        int stride);
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_256_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_256_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct16x16_256_add_sse2(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
+RTCD_EXTERN void (*vpx_idct16x16_256_add)(const tran_low_t* input,
+                                          uint8_t* dest,
+                                          int stride);
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_38_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct16x16_38_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_38_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+RTCD_EXTERN void (*vpx_idct16x16_38_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_1024_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+void vpx_idct32x32_1024_add_sse2(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+RTCD_EXTERN void (*vpx_idct32x32_1024_add)(const tran_low_t* input,
+                                           uint8_t* dest,
+                                           int stride);
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_135_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_135_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct32x32_1024_add_sse2(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+void vpx_idct32x32_135_add_ssse3(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+RTCD_EXTERN void (*vpx_idct32x32_135_add)(const tran_low_t* input,
+                                          uint8_t* dest,
+                                          int stride);
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_1_add_sse2(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+RTCD_EXTERN void (*vpx_idct32x32_1_add)(const tran_low_t* input,
+                                        uint8_t* dest,
+                                        int stride);
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_34_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_34_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+void vpx_idct32x32_34_add_ssse3(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
+RTCD_EXTERN void (*vpx_idct32x32_34_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct4x4_16_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_16_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+RTCD_EXTERN void (*vpx_idct4x4_16_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct4x4_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_1_add_sse2(const tran_low_t* input, uint8_t* dest, int stride);
+RTCD_EXTERN void (*vpx_idct4x4_1_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride);
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_12_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_12_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct8x8_12_add_ssse3(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+RTCD_EXTERN void (*vpx_idct8x8_12_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_1_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_1_add_sse2(const tran_low_t* input, uint8_t* dest, int stride);
+RTCD_EXTERN void (*vpx_idct8x8_1_add)(const tran_low_t* input,
+                                      uint8_t* dest,
+                                      int stride);
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_64_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_64_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_64_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+RTCD_EXTERN void (*vpx_idct8x8_64_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
-int16_t vpx_int_pro_col_sse2(const uint8_t *ref, const int width);
-RTCD_EXTERN int16_t (*vpx_int_pro_col)(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
+int16_t vpx_int_pro_col_sse2(const uint8_t* ref, const int width);
+RTCD_EXTERN int16_t (*vpx_int_pro_col)(const uint8_t* ref, const int width);
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-void vpx_int_pro_row_sse2(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-RTCD_EXTERN void (*vpx_int_pro_row)(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
+void vpx_int_pro_row_sse2(int16_t* hbuf,
+                          const uint8_t* ref,
+                          const int ref_stride,
+                          const int height);
+RTCD_EXTERN void (*vpx_int_pro_row)(int16_t* hbuf,
+                                    const uint8_t* ref,
+                                    const int ref_stride,
+                                    const int height);
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_iwht4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_iwht4x4_16_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_iwht4x4_16_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+RTCD_EXTERN void (*vpx_iwht4x4_16_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_avx2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_16)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+void vpx_lpf_horizontal_16_sse2(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_horizontal_16_avx2(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_16)(uint8_t* s,
+                                          int pitch,
+                                          const uint8_t* blimit,
+                                          const uint8_t* limit,
+                                          const uint8_t* thresh);
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_avx2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_16_dual)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_sse2(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_avx2(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_16_dual)(uint8_t* s,
+                                               int pitch,
+                                               const uint8_t* blimit,
+                                               const uint8_t* limit,
+                                               const uint8_t* thresh);
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_4_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_4)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_4_sse2(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_4)(uint8_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh);
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_4_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_horizontal_4_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_4_dual_sse2(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_horizontal_4_dual)(uint8_t* s,
+                                              int pitch,
+                                              const uint8_t* blimit0,
+                                              const uint8_t* limit0,
+                                              const uint8_t* thresh0,
+                                              const uint8_t* blimit1,
+                                              const uint8_t* limit1,
+                                              const uint8_t* thresh1);
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_8_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_8)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_8_sse2(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_8)(uint8_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh);
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_8_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_horizontal_8_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_8_dual_sse2(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_horizontal_8_dual)(uint8_t* s,
+                                              int pitch,
+                                              const uint8_t* blimit0,
+                                              const uint8_t* limit0,
+                                              const uint8_t* thresh0,
+                                              const uint8_t* blimit1,
+                                              const uint8_t* limit1,
+                                              const uint8_t* thresh1);
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_16)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
+void vpx_lpf_vertical_16_sse2(uint8_t* s,
+                              int pitch,
+                              const uint8_t* blimit,
+                              const uint8_t* limit,
+                              const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_16)(uint8_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit,
+                                        const uint8_t* limit,
+                                        const uint8_t* thresh);
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_16_dual)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_vertical_16_dual_sse2(uint8_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_16_dual)(uint8_t* s,
+                                             int pitch,
+                                             const uint8_t* blimit,
+                                             const uint8_t* limit,
+                                             const uint8_t* thresh);
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_4_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_4)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_4_sse2(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_4)(uint8_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh);
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_4_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_vertical_4_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_4_dual_sse2(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_vertical_4_dual)(uint8_t* s,
+                                            int pitch,
+                                            const uint8_t* blimit0,
+                                            const uint8_t* limit0,
+                                            const uint8_t* thresh0,
+                                            const uint8_t* blimit1,
+                                            const uint8_t* limit1,
+                                            const uint8_t* thresh1);
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_8_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_vertical_8)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_8_sse2(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_vertical_8)(uint8_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh);
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_8_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-RTCD_EXTERN void (*vpx_lpf_vertical_8_dual)(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_8_dual_sse2(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
+RTCD_EXTERN void (*vpx_lpf_vertical_8_dual)(uint8_t* s,
+                                            int pitch,
+                                            const uint8_t* blimit0,
+                                            const uint8_t* limit0,
+                                            const uint8_t* thresh0,
+                                            const uint8_t* blimit1,
+                                            const uint8_t* limit1,
+                                            const uint8_t* thresh1);
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_across_ip_sse2(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-RTCD_EXTERN void (*vpx_mbpost_proc_across_ip)(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
+void vpx_mbpost_proc_across_ip_sse2(unsigned char* dst,
+                                    int pitch,
+                                    int rows,
+                                    int cols,
+                                    int flimit);
+RTCD_EXTERN void (*vpx_mbpost_proc_across_ip)(unsigned char* dst,
+                                              int pitch,
+                                              int rows,
+                                              int cols,
+                                              int flimit);
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_down_sse2(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-RTCD_EXTERN void (*vpx_mbpost_proc_down)(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
+void vpx_mbpost_proc_down_sse2(unsigned char* dst,
+                               int pitch,
+                               int rows,
+                               int cols,
+                               int flimit);
+RTCD_EXTERN void (*vpx_mbpost_proc_down)(unsigned char* dst,
+                                         int pitch,
+                                         int rows,
+                                         int cols,
+                                         int flimit);
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-void vpx_minmax_8x8_sse2(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-RTCD_EXTERN void (*vpx_minmax_8x8)(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
+void vpx_minmax_8x8_sse2(const uint8_t* s,
+                         int p,
+                         const uint8_t* d,
+                         int dp,
+                         int* min,
+                         int* max);
+RTCD_EXTERN void (*vpx_minmax_8x8)(const uint8_t* s,
+                                   int p,
+                                   const uint8_t* d,
+                                   int dp,
+                                   int* min,
+                                   int* max);
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_avx2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
+unsigned int vpx_mse16x16_sse2(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
+unsigned int vpx_mse16x16_avx2(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse16x16)(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse16x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
+unsigned int vpx_mse16x8_sse2(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int recon_stride,
+                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse16x8)(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int recon_stride,
+                                        unsigned int* sse);
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse8x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse8x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
+unsigned int vpx_mse8x16_sse2(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int recon_stride,
+                              unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse8x16)(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int recon_stride,
+                                        unsigned int* sse);
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse8x8)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
+unsigned int vpx_mse8x8_sse2(const uint8_t* src_ptr,
+                             int source_stride,
+                             const uint8_t* ref_ptr,
+                             int recon_stride,
+                             unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse8x8)(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
-void vpx_plane_add_noise_sse2(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
-RTCD_EXTERN void (*vpx_plane_add_noise)(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
+void vpx_plane_add_noise_sse2(uint8_t* start,
+                              const int8_t* noise,
+                              int blackclamp,
+                              int whiteclamp,
+                              int width,
+                              int height,
+                              int pitch);
+RTCD_EXTERN void (*vpx_plane_add_noise)(uint8_t* start,
+                                        const int8_t* noise,
+                                        int blackclamp,
+                                        int whiteclamp,
+                                        int width,
+                                        int height,
+                                        int pitch);
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-void vpx_post_proc_down_and_across_mb_row_sse2(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-RTCD_EXTERN void (*vpx_post_proc_down_and_across_mb_row)(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+void vpx_post_proc_down_and_across_mb_row_sse2(unsigned char* src,
+                                               unsigned char* dst,
+                                               int src_pitch,
+                                               int dst_pitch,
+                                               int cols,
+                                               unsigned char* flimits,
+                                               int size);
+RTCD_EXTERN void (*vpx_post_proc_down_and_across_mb_row)(unsigned char* src,
+                                                         unsigned char* dst,
+                                                         int src_pitch,
+                                                         int dst_pitch,
+                                                         int cols,
+                                                         unsigned char* flimits,
+                                                         int size);
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_quantize_b)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
+void vpx_quantize_b_sse2(const tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* zbin_ptr,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         const int16_t* quant_shift_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+RTCD_EXTERN void (*vpx_quantize_b)(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
 #define vpx_quantize_b_32x32 vpx_quantize_b_32x32_c
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad16x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x16_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad16x16)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad16x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x16_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad16x16_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x3_ssse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x16x3_sse3(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+void vpx_sad16x16x3_ssse3(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x3)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x16x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x16x8_sse4_1(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride,
+                           uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x8)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad16x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad16x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad16x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad16x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad16x8_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad16x8)(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad16x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad16x8_avg_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad16x8_avg)(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            const uint8_t* second_pred);
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x3_ssse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad16x8x3_sse3(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        uint32_t* sad_array);
+void vpx_sad16x8x3_ssse3(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x3)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x8x4d_sse2(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x4d)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad16x8x8_sse4_1(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x8)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x16_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x16_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x16)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x16_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x16x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x16x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x32_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+void vpx_sad32x32x4d_avx2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x64_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x64_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x64)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x64_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x64x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x64x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad4x4)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x4_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad4x4)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad4x4_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x4_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad4x4_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad4x4x3_sse3(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x3)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x4x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad4x4x8_sse4_1(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x8)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad4x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x8_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad4x8)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad4x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x8_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad4x8_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x8x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x8x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad64x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad64x32_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad64x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad64x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad64x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad64x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad64x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad64x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x64_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad64x64_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad64x64)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad64x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad64x64_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad64x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x64x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+void vpx_sad64x64x4d_avx2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad64x64x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad8x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad8x16_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad8x16)(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad8x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad8x16_avg_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad8x16_avg)(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            const uint8_t* second_pred);
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x16x3_sse3(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x3)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad8x16x4d_sse2(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x4d)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x16x8_sse4_1(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x8)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad8x4)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x4_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad8x4)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad8x4_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x4_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad8x4_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x4x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x4x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x4x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x8_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad8x8)(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad8x8_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x8_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad8x8_avg)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           const uint8_t* second_pred);
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad8x8x3_sse3(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x3)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x8x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x4d)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad8x8x8_sse4_1(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x8)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-int vpx_satd_c(const tran_low_t *coeff, int length);
-int vpx_satd_sse2(const tran_low_t *coeff, int length);
-RTCD_EXTERN int (*vpx_satd)(const tran_low_t *coeff, int length);
+int vpx_satd_c(const tran_low_t* coeff, int length);
+int vpx_satd_sse2(const tran_low_t* coeff, int length);
+RTCD_EXTERN int (*vpx_satd)(const tran_low_t* coeff, int length);
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_scaled_2d_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_scaled_2d)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_scaled_2d_ssse3(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+RTCD_EXTERN void (*vpx_scaled_2d)(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_ssse3(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_avx2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_avx2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_ssse3(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x16)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_ssse3(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x8)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x16)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_avx2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x64)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x4)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x8)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_avx2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x64)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_ssse3(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x16)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x4)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x8)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-void vpx_subtract_block_sse2(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-RTCD_EXTERN void (*vpx_subtract_block)(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
+void vpx_subtract_block_sse2(int rows,
+                             int cols,
+                             int16_t* diff_ptr,
+                             ptrdiff_t diff_stride,
+                             const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             const uint8_t* pred_ptr,
+                             ptrdiff_t pred_stride);
+RTCD_EXTERN void (*vpx_subtract_block)(int rows,
+                                       int cols,
+                                       int16_t* diff_ptr,
+                                       ptrdiff_t diff_stride,
+                                       const uint8_t* src_ptr,
+                                       ptrdiff_t src_stride,
+                                       const uint8_t* pred_ptr,
+                                       ptrdiff_t pred_stride);
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
-uint64_t vpx_sum_squares_2d_i16_sse2(const int16_t *src, int stride, int size);
-RTCD_EXTERN uint64_t (*vpx_sum_squares_2d_i16)(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_sse2(const int16_t* src, int stride, int size);
+RTCD_EXTERN uint64_t (*vpx_sum_squares_2d_i16)(const int16_t* src,
+                                               int stride,
+                                               int size);
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_16x16_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_16x16)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_32x32_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_32x32)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_4x4_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_4x4)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_tm_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_8x8_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+RTCD_EXTERN void (*vpx_tm_predictor_8x8)(uint8_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint8_t* above,
+                                         const uint8_t* left);
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_16x16_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_16x16)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_32x32_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_32x32)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_4x4_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_4x4)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_v_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_8x8_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+RTCD_EXTERN void (*vpx_v_predictor_8x8)(uint8_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint8_t* above,
+                                        const uint8_t* left);
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x16_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance16x16_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x16)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance16x8_sse2(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x8)(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x16_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance32x16_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x16)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance32x32_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x64_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x64)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance4x4)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x4_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance4x4)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance4x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x8_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance4x8)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance64x32_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance64x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x64_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance64x64_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance64x64)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance8x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance8x16_sse2(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance8x16)(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance8x4)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x4_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance8x4)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance8x8)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x8_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance8x8)(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
-int vpx_vector_var_sse2(const int16_t *ref, const int16_t *src, const int bwl);
-RTCD_EXTERN int (*vpx_vector_var)(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
+int vpx_vector_var_sse2(const int16_t* ref, const int16_t* src, const int bwl);
+RTCD_EXTERN int (*vpx_vector_var)(const int16_t* ref,
+                                  const int16_t* src,
+                                  const int bwl);
 
 void vpx_dsp_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vpx_avg_4x4 = vpx_avg_4x4_c;
-    if (flags & HAS_SSE2) vpx_avg_4x4 = vpx_avg_4x4_sse2;
-    vpx_avg_8x8 = vpx_avg_8x8_c;
-    if (flags & HAS_SSE2) vpx_avg_8x8 = vpx_avg_8x8_sse2;
-    vpx_comp_avg_pred = vpx_comp_avg_pred_c;
-    if (flags & HAS_SSE2) vpx_comp_avg_pred = vpx_comp_avg_pred_sse2;
-    vpx_convolve8 = vpx_convolve8_c;
-    if (flags & HAS_SSE2) vpx_convolve8 = vpx_convolve8_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8 = vpx_convolve8_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8 = vpx_convolve8_avx2;
-    vpx_convolve8_avg = vpx_convolve8_avg_c;
-    if (flags & HAS_SSE2) vpx_convolve8_avg = vpx_convolve8_avg_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg = vpx_convolve8_avg_ssse3;
-    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_c;
-    if (flags & HAS_SSE2) vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_ssse3;
-    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_c;
-    if (flags & HAS_SSE2) vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_ssse3;
-    vpx_convolve8_horiz = vpx_convolve8_horiz_c;
-    if (flags & HAS_SSE2) vpx_convolve8_horiz = vpx_convolve8_horiz_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_horiz = vpx_convolve8_horiz_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8_horiz = vpx_convolve8_horiz_avx2;
-    vpx_convolve8_vert = vpx_convolve8_vert_c;
-    if (flags & HAS_SSE2) vpx_convolve8_vert = vpx_convolve8_vert_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_vert = vpx_convolve8_vert_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8_vert = vpx_convolve8_vert_avx2;
-    vpx_convolve_avg = vpx_convolve_avg_c;
-    if (flags & HAS_SSE2) vpx_convolve_avg = vpx_convolve_avg_sse2;
-    vpx_convolve_copy = vpx_convolve_copy_c;
-    if (flags & HAS_SSE2) vpx_convolve_copy = vpx_convolve_copy_sse2;
-    vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_ssse3;
-    vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_ssse3;
-    vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_ssse3;
-    vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_ssse3;
-    vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_ssse3;
-    vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_ssse3;
-    vpx_d207_predictor_4x4 = vpx_d207_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_d207_predictor_4x4 = vpx_d207_predictor_4x4_sse2;
-    vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_ssse3;
-    vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_ssse3;
-    vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_ssse3;
-    vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_sse2;
-    vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_sse2;
-    vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_ssse3;
-    vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_ssse3;
-    vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_ssse3;
-    vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_ssse3;
-    vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_sse2;
-    vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_sse2;
-    vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_sse2;
-    vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_sse2;
-    vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_sse2;
-    vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_sse2;
-    vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_sse2;
-    vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_sse2;
-    vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_sse2;
-    vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_sse2;
-    vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_sse2;
-    vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_sse2;
-    vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_sse2;
-    vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_sse2;
-    vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_sse2;
-    vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_sse2;
-    vpx_fdct16x16 = vpx_fdct16x16_c;
-    if (flags & HAS_SSE2) vpx_fdct16x16 = vpx_fdct16x16_sse2;
-    vpx_fdct16x16_1 = vpx_fdct16x16_1_c;
-    if (flags & HAS_SSE2) vpx_fdct16x16_1 = vpx_fdct16x16_1_sse2;
-    vpx_fdct32x32 = vpx_fdct32x32_c;
-    if (flags & HAS_SSE2) vpx_fdct32x32 = vpx_fdct32x32_sse2;
-    vpx_fdct32x32_1 = vpx_fdct32x32_1_c;
-    if (flags & HAS_SSE2) vpx_fdct32x32_1 = vpx_fdct32x32_1_sse2;
-    vpx_fdct32x32_rd = vpx_fdct32x32_rd_c;
-    if (flags & HAS_SSE2) vpx_fdct32x32_rd = vpx_fdct32x32_rd_sse2;
-    vpx_fdct4x4 = vpx_fdct4x4_c;
-    if (flags & HAS_SSE2) vpx_fdct4x4 = vpx_fdct4x4_sse2;
-    vpx_fdct4x4_1 = vpx_fdct4x4_1_c;
-    if (flags & HAS_SSE2) vpx_fdct4x4_1 = vpx_fdct4x4_1_sse2;
-    vpx_fdct8x8 = vpx_fdct8x8_c;
-    if (flags & HAS_SSE2) vpx_fdct8x8 = vpx_fdct8x8_sse2;
-    vpx_fdct8x8_1 = vpx_fdct8x8_1_c;
-    if (flags & HAS_SSE2) vpx_fdct8x8_1 = vpx_fdct8x8_1_sse2;
-    vpx_get16x16var = vpx_get16x16var_c;
-    if (flags & HAS_SSE2) vpx_get16x16var = vpx_get16x16var_sse2;
-    if (flags & HAS_AVX2) vpx_get16x16var = vpx_get16x16var_avx2;
-    vpx_get8x8var = vpx_get8x8var_c;
-    if (flags & HAS_SSE2) vpx_get8x8var = vpx_get8x8var_sse2;
-    vpx_get_mb_ss = vpx_get_mb_ss_c;
-    if (flags & HAS_SSE2) vpx_get_mb_ss = vpx_get_mb_ss_sse2;
-    vpx_h_predictor_16x16 = vpx_h_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_h_predictor_16x16 = vpx_h_predictor_16x16_sse2;
-    vpx_h_predictor_32x32 = vpx_h_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_h_predictor_32x32 = vpx_h_predictor_32x32_sse2;
-    vpx_h_predictor_4x4 = vpx_h_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_h_predictor_4x4 = vpx_h_predictor_4x4_sse2;
-    vpx_h_predictor_8x8 = vpx_h_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_h_predictor_8x8 = vpx_h_predictor_8x8_sse2;
-    vpx_hadamard_16x16 = vpx_hadamard_16x16_c;
-    if (flags & HAS_SSE2) vpx_hadamard_16x16 = vpx_hadamard_16x16_sse2;
-    vpx_hadamard_8x8 = vpx_hadamard_8x8_c;
-    if (flags & HAS_SSE2) vpx_hadamard_8x8 = vpx_hadamard_8x8_sse2;
-    vpx_highbd_10_mse16x16 = vpx_highbd_10_mse16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_mse16x16 = vpx_highbd_10_mse16x16_sse2;
-    vpx_highbd_10_mse8x8 = vpx_highbd_10_mse8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_mse8x8 = vpx_highbd_10_mse8x8_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance16x16 = vpx_highbd_10_sub_pixel_avg_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance16x16 = vpx_highbd_10_sub_pixel_avg_variance16x16_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance16x32 = vpx_highbd_10_sub_pixel_avg_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance16x32 = vpx_highbd_10_sub_pixel_avg_variance16x32_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance16x8 = vpx_highbd_10_sub_pixel_avg_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance16x8 = vpx_highbd_10_sub_pixel_avg_variance16x8_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance32x16 = vpx_highbd_10_sub_pixel_avg_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance32x16 = vpx_highbd_10_sub_pixel_avg_variance32x16_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance32x32 = vpx_highbd_10_sub_pixel_avg_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance32x32 = vpx_highbd_10_sub_pixel_avg_variance32x32_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance32x64 = vpx_highbd_10_sub_pixel_avg_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance32x64 = vpx_highbd_10_sub_pixel_avg_variance32x64_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance64x32 = vpx_highbd_10_sub_pixel_avg_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance64x32 = vpx_highbd_10_sub_pixel_avg_variance64x32_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance64x64 = vpx_highbd_10_sub_pixel_avg_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance64x64 = vpx_highbd_10_sub_pixel_avg_variance64x64_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance8x16 = vpx_highbd_10_sub_pixel_avg_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance8x16 = vpx_highbd_10_sub_pixel_avg_variance8x16_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance8x4 = vpx_highbd_10_sub_pixel_avg_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance8x4 = vpx_highbd_10_sub_pixel_avg_variance8x4_sse2;
-    vpx_highbd_10_sub_pixel_avg_variance8x8 = vpx_highbd_10_sub_pixel_avg_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_avg_variance8x8 = vpx_highbd_10_sub_pixel_avg_variance8x8_sse2;
-    vpx_highbd_10_sub_pixel_variance16x16 = vpx_highbd_10_sub_pixel_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance16x16 = vpx_highbd_10_sub_pixel_variance16x16_sse2;
-    vpx_highbd_10_sub_pixel_variance16x32 = vpx_highbd_10_sub_pixel_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance16x32 = vpx_highbd_10_sub_pixel_variance16x32_sse2;
-    vpx_highbd_10_sub_pixel_variance16x8 = vpx_highbd_10_sub_pixel_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance16x8 = vpx_highbd_10_sub_pixel_variance16x8_sse2;
-    vpx_highbd_10_sub_pixel_variance32x16 = vpx_highbd_10_sub_pixel_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance32x16 = vpx_highbd_10_sub_pixel_variance32x16_sse2;
-    vpx_highbd_10_sub_pixel_variance32x32 = vpx_highbd_10_sub_pixel_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance32x32 = vpx_highbd_10_sub_pixel_variance32x32_sse2;
-    vpx_highbd_10_sub_pixel_variance32x64 = vpx_highbd_10_sub_pixel_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance32x64 = vpx_highbd_10_sub_pixel_variance32x64_sse2;
-    vpx_highbd_10_sub_pixel_variance64x32 = vpx_highbd_10_sub_pixel_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance64x32 = vpx_highbd_10_sub_pixel_variance64x32_sse2;
-    vpx_highbd_10_sub_pixel_variance64x64 = vpx_highbd_10_sub_pixel_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance64x64 = vpx_highbd_10_sub_pixel_variance64x64_sse2;
-    vpx_highbd_10_sub_pixel_variance8x16 = vpx_highbd_10_sub_pixel_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance8x16 = vpx_highbd_10_sub_pixel_variance8x16_sse2;
-    vpx_highbd_10_sub_pixel_variance8x4 = vpx_highbd_10_sub_pixel_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance8x4 = vpx_highbd_10_sub_pixel_variance8x4_sse2;
-    vpx_highbd_10_sub_pixel_variance8x8 = vpx_highbd_10_sub_pixel_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_sub_pixel_variance8x8 = vpx_highbd_10_sub_pixel_variance8x8_sse2;
-    vpx_highbd_10_variance16x16 = vpx_highbd_10_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance16x16 = vpx_highbd_10_variance16x16_sse2;
-    vpx_highbd_10_variance16x32 = vpx_highbd_10_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance16x32 = vpx_highbd_10_variance16x32_sse2;
-    vpx_highbd_10_variance16x8 = vpx_highbd_10_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance16x8 = vpx_highbd_10_variance16x8_sse2;
-    vpx_highbd_10_variance32x16 = vpx_highbd_10_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance32x16 = vpx_highbd_10_variance32x16_sse2;
-    vpx_highbd_10_variance32x32 = vpx_highbd_10_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance32x32 = vpx_highbd_10_variance32x32_sse2;
-    vpx_highbd_10_variance32x64 = vpx_highbd_10_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance32x64 = vpx_highbd_10_variance32x64_sse2;
-    vpx_highbd_10_variance64x32 = vpx_highbd_10_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance64x32 = vpx_highbd_10_variance64x32_sse2;
-    vpx_highbd_10_variance64x64 = vpx_highbd_10_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance64x64 = vpx_highbd_10_variance64x64_sse2;
-    vpx_highbd_10_variance8x16 = vpx_highbd_10_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance8x16 = vpx_highbd_10_variance8x16_sse2;
-    vpx_highbd_10_variance8x8 = vpx_highbd_10_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_10_variance8x8 = vpx_highbd_10_variance8x8_sse2;
-    vpx_highbd_12_mse16x16 = vpx_highbd_12_mse16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_mse16x16 = vpx_highbd_12_mse16x16_sse2;
-    vpx_highbd_12_mse8x8 = vpx_highbd_12_mse8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_mse8x8 = vpx_highbd_12_mse8x8_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance16x16 = vpx_highbd_12_sub_pixel_avg_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance16x16 = vpx_highbd_12_sub_pixel_avg_variance16x16_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance16x32 = vpx_highbd_12_sub_pixel_avg_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance16x32 = vpx_highbd_12_sub_pixel_avg_variance16x32_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance16x8 = vpx_highbd_12_sub_pixel_avg_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance16x8 = vpx_highbd_12_sub_pixel_avg_variance16x8_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance32x16 = vpx_highbd_12_sub_pixel_avg_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance32x16 = vpx_highbd_12_sub_pixel_avg_variance32x16_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance32x32 = vpx_highbd_12_sub_pixel_avg_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance32x32 = vpx_highbd_12_sub_pixel_avg_variance32x32_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance32x64 = vpx_highbd_12_sub_pixel_avg_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance32x64 = vpx_highbd_12_sub_pixel_avg_variance32x64_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance64x32 = vpx_highbd_12_sub_pixel_avg_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance64x32 = vpx_highbd_12_sub_pixel_avg_variance64x32_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance64x64 = vpx_highbd_12_sub_pixel_avg_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance64x64 = vpx_highbd_12_sub_pixel_avg_variance64x64_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance8x16 = vpx_highbd_12_sub_pixel_avg_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance8x16 = vpx_highbd_12_sub_pixel_avg_variance8x16_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance8x4 = vpx_highbd_12_sub_pixel_avg_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance8x4 = vpx_highbd_12_sub_pixel_avg_variance8x4_sse2;
-    vpx_highbd_12_sub_pixel_avg_variance8x8 = vpx_highbd_12_sub_pixel_avg_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_avg_variance8x8 = vpx_highbd_12_sub_pixel_avg_variance8x8_sse2;
-    vpx_highbd_12_sub_pixel_variance16x16 = vpx_highbd_12_sub_pixel_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance16x16 = vpx_highbd_12_sub_pixel_variance16x16_sse2;
-    vpx_highbd_12_sub_pixel_variance16x32 = vpx_highbd_12_sub_pixel_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance16x32 = vpx_highbd_12_sub_pixel_variance16x32_sse2;
-    vpx_highbd_12_sub_pixel_variance16x8 = vpx_highbd_12_sub_pixel_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance16x8 = vpx_highbd_12_sub_pixel_variance16x8_sse2;
-    vpx_highbd_12_sub_pixel_variance32x16 = vpx_highbd_12_sub_pixel_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance32x16 = vpx_highbd_12_sub_pixel_variance32x16_sse2;
-    vpx_highbd_12_sub_pixel_variance32x32 = vpx_highbd_12_sub_pixel_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance32x32 = vpx_highbd_12_sub_pixel_variance32x32_sse2;
-    vpx_highbd_12_sub_pixel_variance32x64 = vpx_highbd_12_sub_pixel_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance32x64 = vpx_highbd_12_sub_pixel_variance32x64_sse2;
-    vpx_highbd_12_sub_pixel_variance64x32 = vpx_highbd_12_sub_pixel_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance64x32 = vpx_highbd_12_sub_pixel_variance64x32_sse2;
-    vpx_highbd_12_sub_pixel_variance64x64 = vpx_highbd_12_sub_pixel_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance64x64 = vpx_highbd_12_sub_pixel_variance64x64_sse2;
-    vpx_highbd_12_sub_pixel_variance8x16 = vpx_highbd_12_sub_pixel_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance8x16 = vpx_highbd_12_sub_pixel_variance8x16_sse2;
-    vpx_highbd_12_sub_pixel_variance8x4 = vpx_highbd_12_sub_pixel_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance8x4 = vpx_highbd_12_sub_pixel_variance8x4_sse2;
-    vpx_highbd_12_sub_pixel_variance8x8 = vpx_highbd_12_sub_pixel_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_sub_pixel_variance8x8 = vpx_highbd_12_sub_pixel_variance8x8_sse2;
-    vpx_highbd_12_variance16x16 = vpx_highbd_12_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance16x16 = vpx_highbd_12_variance16x16_sse2;
-    vpx_highbd_12_variance16x32 = vpx_highbd_12_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance16x32 = vpx_highbd_12_variance16x32_sse2;
-    vpx_highbd_12_variance16x8 = vpx_highbd_12_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance16x8 = vpx_highbd_12_variance16x8_sse2;
-    vpx_highbd_12_variance32x16 = vpx_highbd_12_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance32x16 = vpx_highbd_12_variance32x16_sse2;
-    vpx_highbd_12_variance32x32 = vpx_highbd_12_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance32x32 = vpx_highbd_12_variance32x32_sse2;
-    vpx_highbd_12_variance32x64 = vpx_highbd_12_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance32x64 = vpx_highbd_12_variance32x64_sse2;
-    vpx_highbd_12_variance64x32 = vpx_highbd_12_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance64x32 = vpx_highbd_12_variance64x32_sse2;
-    vpx_highbd_12_variance64x64 = vpx_highbd_12_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance64x64 = vpx_highbd_12_variance64x64_sse2;
-    vpx_highbd_12_variance8x16 = vpx_highbd_12_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance8x16 = vpx_highbd_12_variance8x16_sse2;
-    vpx_highbd_12_variance8x8 = vpx_highbd_12_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_12_variance8x8 = vpx_highbd_12_variance8x8_sse2;
-    vpx_highbd_8_mse16x16 = vpx_highbd_8_mse16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_mse16x16 = vpx_highbd_8_mse16x16_sse2;
-    vpx_highbd_8_mse8x8 = vpx_highbd_8_mse8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_mse8x8 = vpx_highbd_8_mse8x8_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance16x16 = vpx_highbd_8_sub_pixel_avg_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance16x16 = vpx_highbd_8_sub_pixel_avg_variance16x16_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance16x32 = vpx_highbd_8_sub_pixel_avg_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance16x32 = vpx_highbd_8_sub_pixel_avg_variance16x32_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance16x8 = vpx_highbd_8_sub_pixel_avg_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance16x8 = vpx_highbd_8_sub_pixel_avg_variance16x8_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance32x16 = vpx_highbd_8_sub_pixel_avg_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance32x16 = vpx_highbd_8_sub_pixel_avg_variance32x16_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance32x32 = vpx_highbd_8_sub_pixel_avg_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance32x32 = vpx_highbd_8_sub_pixel_avg_variance32x32_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance32x64 = vpx_highbd_8_sub_pixel_avg_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance32x64 = vpx_highbd_8_sub_pixel_avg_variance32x64_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance64x32 = vpx_highbd_8_sub_pixel_avg_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance64x32 = vpx_highbd_8_sub_pixel_avg_variance64x32_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance64x64 = vpx_highbd_8_sub_pixel_avg_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance64x64 = vpx_highbd_8_sub_pixel_avg_variance64x64_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance8x16 = vpx_highbd_8_sub_pixel_avg_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance8x16 = vpx_highbd_8_sub_pixel_avg_variance8x16_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance8x4 = vpx_highbd_8_sub_pixel_avg_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance8x4 = vpx_highbd_8_sub_pixel_avg_variance8x4_sse2;
-    vpx_highbd_8_sub_pixel_avg_variance8x8 = vpx_highbd_8_sub_pixel_avg_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_avg_variance8x8 = vpx_highbd_8_sub_pixel_avg_variance8x8_sse2;
-    vpx_highbd_8_sub_pixel_variance16x16 = vpx_highbd_8_sub_pixel_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance16x16 = vpx_highbd_8_sub_pixel_variance16x16_sse2;
-    vpx_highbd_8_sub_pixel_variance16x32 = vpx_highbd_8_sub_pixel_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance16x32 = vpx_highbd_8_sub_pixel_variance16x32_sse2;
-    vpx_highbd_8_sub_pixel_variance16x8 = vpx_highbd_8_sub_pixel_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance16x8 = vpx_highbd_8_sub_pixel_variance16x8_sse2;
-    vpx_highbd_8_sub_pixel_variance32x16 = vpx_highbd_8_sub_pixel_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance32x16 = vpx_highbd_8_sub_pixel_variance32x16_sse2;
-    vpx_highbd_8_sub_pixel_variance32x32 = vpx_highbd_8_sub_pixel_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance32x32 = vpx_highbd_8_sub_pixel_variance32x32_sse2;
-    vpx_highbd_8_sub_pixel_variance32x64 = vpx_highbd_8_sub_pixel_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance32x64 = vpx_highbd_8_sub_pixel_variance32x64_sse2;
-    vpx_highbd_8_sub_pixel_variance64x32 = vpx_highbd_8_sub_pixel_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance64x32 = vpx_highbd_8_sub_pixel_variance64x32_sse2;
-    vpx_highbd_8_sub_pixel_variance64x64 = vpx_highbd_8_sub_pixel_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance64x64 = vpx_highbd_8_sub_pixel_variance64x64_sse2;
-    vpx_highbd_8_sub_pixel_variance8x16 = vpx_highbd_8_sub_pixel_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance8x16 = vpx_highbd_8_sub_pixel_variance8x16_sse2;
-    vpx_highbd_8_sub_pixel_variance8x4 = vpx_highbd_8_sub_pixel_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance8x4 = vpx_highbd_8_sub_pixel_variance8x4_sse2;
-    vpx_highbd_8_sub_pixel_variance8x8 = vpx_highbd_8_sub_pixel_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_sub_pixel_variance8x8 = vpx_highbd_8_sub_pixel_variance8x8_sse2;
-    vpx_highbd_8_variance16x16 = vpx_highbd_8_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance16x16 = vpx_highbd_8_variance16x16_sse2;
-    vpx_highbd_8_variance16x32 = vpx_highbd_8_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance16x32 = vpx_highbd_8_variance16x32_sse2;
-    vpx_highbd_8_variance16x8 = vpx_highbd_8_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance16x8 = vpx_highbd_8_variance16x8_sse2;
-    vpx_highbd_8_variance32x16 = vpx_highbd_8_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance32x16 = vpx_highbd_8_variance32x16_sse2;
-    vpx_highbd_8_variance32x32 = vpx_highbd_8_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance32x32 = vpx_highbd_8_variance32x32_sse2;
-    vpx_highbd_8_variance32x64 = vpx_highbd_8_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance32x64 = vpx_highbd_8_variance32x64_sse2;
-    vpx_highbd_8_variance64x32 = vpx_highbd_8_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance64x32 = vpx_highbd_8_variance64x32_sse2;
-    vpx_highbd_8_variance64x64 = vpx_highbd_8_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance64x64 = vpx_highbd_8_variance64x64_sse2;
-    vpx_highbd_8_variance8x16 = vpx_highbd_8_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance8x16 = vpx_highbd_8_variance8x16_sse2;
-    vpx_highbd_8_variance8x8 = vpx_highbd_8_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_8_variance8x8 = vpx_highbd_8_variance8x8_sse2;
-    vpx_highbd_convolve8 = vpx_highbd_convolve8_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8 = vpx_highbd_convolve8_avx2;
-    vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_avx2;
-    vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_avx2;
-    vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_avx2;
-    vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_avx2;
-    vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_c;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_avx2;
-    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_avx2;
-    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_c;
-    if (flags & HAS_SSE2) vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_avx2;
-    vpx_highbd_dc_predictor_16x16 = vpx_highbd_dc_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_dc_predictor_16x16 = vpx_highbd_dc_predictor_16x16_sse2;
-    vpx_highbd_dc_predictor_32x32 = vpx_highbd_dc_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_dc_predictor_32x32 = vpx_highbd_dc_predictor_32x32_sse2;
-    vpx_highbd_dc_predictor_4x4 = vpx_highbd_dc_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_dc_predictor_4x4 = vpx_highbd_dc_predictor_4x4_sse2;
-    vpx_highbd_dc_predictor_8x8 = vpx_highbd_dc_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_dc_predictor_8x8 = vpx_highbd_dc_predictor_8x8_sse2;
-    vpx_highbd_fdct16x16 = vpx_highbd_fdct16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct16x16 = vpx_highbd_fdct16x16_sse2;
-    vpx_highbd_fdct32x32 = vpx_highbd_fdct32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct32x32 = vpx_highbd_fdct32x32_sse2;
-    vpx_highbd_fdct32x32_rd = vpx_highbd_fdct32x32_rd_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct32x32_rd = vpx_highbd_fdct32x32_rd_sse2;
-    vpx_highbd_fdct4x4 = vpx_highbd_fdct4x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct4x4 = vpx_highbd_fdct4x4_sse2;
-    vpx_highbd_fdct8x8 = vpx_highbd_fdct8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_fdct8x8 = vpx_highbd_fdct8x8_sse2;
-    vpx_highbd_idct16x16_10_add = vpx_highbd_idct16x16_10_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct16x16_10_add = vpx_highbd_idct16x16_10_add_sse2;
-    vpx_highbd_idct16x16_1_add = vpx_highbd_idct16x16_1_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct16x16_1_add = vpx_highbd_idct16x16_1_add_sse2;
-    vpx_highbd_idct16x16_256_add = vpx_highbd_idct16x16_256_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct16x16_256_add = vpx_highbd_idct16x16_256_add_sse2;
-    vpx_highbd_idct16x16_38_add = vpx_highbd_idct16x16_38_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct16x16_38_add = vpx_highbd_idct16x16_256_add_sse2;
-    vpx_highbd_idct32x32_1_add = vpx_highbd_idct32x32_1_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct32x32_1_add = vpx_highbd_idct32x32_1_add_sse2;
-    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse4_1;
-    vpx_highbd_idct4x4_1_add = vpx_highbd_idct4x4_1_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct4x4_1_add = vpx_highbd_idct4x4_1_add_sse2;
-    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse4_1;
-    vpx_highbd_idct8x8_1_add = vpx_highbd_idct8x8_1_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct8x8_1_add = vpx_highbd_idct8x8_1_add_sse2;
-    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_c;
-    if (flags & HAS_SSE2) vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse4_1;
-    vpx_highbd_lpf_horizontal_16 = vpx_highbd_lpf_horizontal_16_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_16 = vpx_highbd_lpf_horizontal_16_sse2;
-    vpx_highbd_lpf_horizontal_16_dual = vpx_highbd_lpf_horizontal_16_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_16_dual = vpx_highbd_lpf_horizontal_16_dual_sse2;
-    vpx_highbd_lpf_horizontal_4 = vpx_highbd_lpf_horizontal_4_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_4 = vpx_highbd_lpf_horizontal_4_sse2;
-    vpx_highbd_lpf_horizontal_4_dual = vpx_highbd_lpf_horizontal_4_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_4_dual = vpx_highbd_lpf_horizontal_4_dual_sse2;
-    vpx_highbd_lpf_horizontal_8 = vpx_highbd_lpf_horizontal_8_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_8 = vpx_highbd_lpf_horizontal_8_sse2;
-    vpx_highbd_lpf_horizontal_8_dual = vpx_highbd_lpf_horizontal_8_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_horizontal_8_dual = vpx_highbd_lpf_horizontal_8_dual_sse2;
-    vpx_highbd_lpf_vertical_16 = vpx_highbd_lpf_vertical_16_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_16 = vpx_highbd_lpf_vertical_16_sse2;
-    vpx_highbd_lpf_vertical_16_dual = vpx_highbd_lpf_vertical_16_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_16_dual = vpx_highbd_lpf_vertical_16_dual_sse2;
-    vpx_highbd_lpf_vertical_4 = vpx_highbd_lpf_vertical_4_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_4 = vpx_highbd_lpf_vertical_4_sse2;
-    vpx_highbd_lpf_vertical_4_dual = vpx_highbd_lpf_vertical_4_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_4_dual = vpx_highbd_lpf_vertical_4_dual_sse2;
-    vpx_highbd_lpf_vertical_8 = vpx_highbd_lpf_vertical_8_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_8 = vpx_highbd_lpf_vertical_8_sse2;
-    vpx_highbd_lpf_vertical_8_dual = vpx_highbd_lpf_vertical_8_dual_c;
-    if (flags & HAS_SSE2) vpx_highbd_lpf_vertical_8_dual = vpx_highbd_lpf_vertical_8_dual_sse2;
-    vpx_highbd_quantize_b = vpx_highbd_quantize_b_c;
-    if (flags & HAS_SSE2) vpx_highbd_quantize_b = vpx_highbd_quantize_b_sse2;
-    vpx_highbd_quantize_b_32x32 = vpx_highbd_quantize_b_32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_quantize_b_32x32 = vpx_highbd_quantize_b_32x32_sse2;
-    vpx_highbd_sad16x16 = vpx_highbd_sad16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x16 = vpx_highbd_sad16x16_sse2;
-    vpx_highbd_sad16x16_avg = vpx_highbd_sad16x16_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x16_avg = vpx_highbd_sad16x16_avg_sse2;
-    vpx_highbd_sad16x16x4d = vpx_highbd_sad16x16x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x16x4d = vpx_highbd_sad16x16x4d_sse2;
-    vpx_highbd_sad16x32 = vpx_highbd_sad16x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x32 = vpx_highbd_sad16x32_sse2;
-    vpx_highbd_sad16x32_avg = vpx_highbd_sad16x32_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x32_avg = vpx_highbd_sad16x32_avg_sse2;
-    vpx_highbd_sad16x32x4d = vpx_highbd_sad16x32x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x32x4d = vpx_highbd_sad16x32x4d_sse2;
-    vpx_highbd_sad16x8 = vpx_highbd_sad16x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x8 = vpx_highbd_sad16x8_sse2;
-    vpx_highbd_sad16x8_avg = vpx_highbd_sad16x8_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x8_avg = vpx_highbd_sad16x8_avg_sse2;
-    vpx_highbd_sad16x8x4d = vpx_highbd_sad16x8x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad16x8x4d = vpx_highbd_sad16x8x4d_sse2;
-    vpx_highbd_sad32x16 = vpx_highbd_sad32x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x16 = vpx_highbd_sad32x16_sse2;
-    vpx_highbd_sad32x16_avg = vpx_highbd_sad32x16_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x16_avg = vpx_highbd_sad32x16_avg_sse2;
-    vpx_highbd_sad32x16x4d = vpx_highbd_sad32x16x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x16x4d = vpx_highbd_sad32x16x4d_sse2;
-    vpx_highbd_sad32x32 = vpx_highbd_sad32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x32 = vpx_highbd_sad32x32_sse2;
-    vpx_highbd_sad32x32_avg = vpx_highbd_sad32x32_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x32_avg = vpx_highbd_sad32x32_avg_sse2;
-    vpx_highbd_sad32x32x4d = vpx_highbd_sad32x32x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x32x4d = vpx_highbd_sad32x32x4d_sse2;
-    vpx_highbd_sad32x64 = vpx_highbd_sad32x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x64 = vpx_highbd_sad32x64_sse2;
-    vpx_highbd_sad32x64_avg = vpx_highbd_sad32x64_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x64_avg = vpx_highbd_sad32x64_avg_sse2;
-    vpx_highbd_sad32x64x4d = vpx_highbd_sad32x64x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad32x64x4d = vpx_highbd_sad32x64x4d_sse2;
-    vpx_highbd_sad4x4x4d = vpx_highbd_sad4x4x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad4x4x4d = vpx_highbd_sad4x4x4d_sse2;
-    vpx_highbd_sad4x8x4d = vpx_highbd_sad4x8x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad4x8x4d = vpx_highbd_sad4x8x4d_sse2;
-    vpx_highbd_sad64x32 = vpx_highbd_sad64x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x32 = vpx_highbd_sad64x32_sse2;
-    vpx_highbd_sad64x32_avg = vpx_highbd_sad64x32_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x32_avg = vpx_highbd_sad64x32_avg_sse2;
-    vpx_highbd_sad64x32x4d = vpx_highbd_sad64x32x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x32x4d = vpx_highbd_sad64x32x4d_sse2;
-    vpx_highbd_sad64x64 = vpx_highbd_sad64x64_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x64 = vpx_highbd_sad64x64_sse2;
-    vpx_highbd_sad64x64_avg = vpx_highbd_sad64x64_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x64_avg = vpx_highbd_sad64x64_avg_sse2;
-    vpx_highbd_sad64x64x4d = vpx_highbd_sad64x64x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad64x64x4d = vpx_highbd_sad64x64x4d_sse2;
-    vpx_highbd_sad8x16 = vpx_highbd_sad8x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x16 = vpx_highbd_sad8x16_sse2;
-    vpx_highbd_sad8x16_avg = vpx_highbd_sad8x16_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x16_avg = vpx_highbd_sad8x16_avg_sse2;
-    vpx_highbd_sad8x16x4d = vpx_highbd_sad8x16x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x16x4d = vpx_highbd_sad8x16x4d_sse2;
-    vpx_highbd_sad8x4 = vpx_highbd_sad8x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x4 = vpx_highbd_sad8x4_sse2;
-    vpx_highbd_sad8x4_avg = vpx_highbd_sad8x4_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x4_avg = vpx_highbd_sad8x4_avg_sse2;
-    vpx_highbd_sad8x4x4d = vpx_highbd_sad8x4x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x4x4d = vpx_highbd_sad8x4x4d_sse2;
-    vpx_highbd_sad8x8 = vpx_highbd_sad8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x8 = vpx_highbd_sad8x8_sse2;
-    vpx_highbd_sad8x8_avg = vpx_highbd_sad8x8_avg_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x8_avg = vpx_highbd_sad8x8_avg_sse2;
-    vpx_highbd_sad8x8x4d = vpx_highbd_sad8x8x4d_c;
-    if (flags & HAS_SSE2) vpx_highbd_sad8x8x4d = vpx_highbd_sad8x8x4d_sse2;
-    vpx_highbd_tm_predictor_16x16 = vpx_highbd_tm_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_tm_predictor_16x16 = vpx_highbd_tm_predictor_16x16_sse2;
-    vpx_highbd_tm_predictor_32x32 = vpx_highbd_tm_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_tm_predictor_32x32 = vpx_highbd_tm_predictor_32x32_sse2;
-    vpx_highbd_tm_predictor_4x4 = vpx_highbd_tm_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_tm_predictor_4x4 = vpx_highbd_tm_predictor_4x4_sse2;
-    vpx_highbd_tm_predictor_8x8 = vpx_highbd_tm_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_tm_predictor_8x8 = vpx_highbd_tm_predictor_8x8_sse2;
-    vpx_highbd_v_predictor_16x16 = vpx_highbd_v_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_highbd_v_predictor_16x16 = vpx_highbd_v_predictor_16x16_sse2;
-    vpx_highbd_v_predictor_32x32 = vpx_highbd_v_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_highbd_v_predictor_32x32 = vpx_highbd_v_predictor_32x32_sse2;
-    vpx_highbd_v_predictor_4x4 = vpx_highbd_v_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_highbd_v_predictor_4x4 = vpx_highbd_v_predictor_4x4_sse2;
-    vpx_highbd_v_predictor_8x8 = vpx_highbd_v_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_highbd_v_predictor_8x8 = vpx_highbd_v_predictor_8x8_sse2;
-    vpx_idct16x16_10_add = vpx_idct16x16_10_add_c;
-    if (flags & HAS_SSE2) vpx_idct16x16_10_add = vpx_idct16x16_10_add_sse2;
-    vpx_idct16x16_1_add = vpx_idct16x16_1_add_c;
-    if (flags & HAS_SSE2) vpx_idct16x16_1_add = vpx_idct16x16_1_add_sse2;
-    vpx_idct16x16_256_add = vpx_idct16x16_256_add_c;
-    if (flags & HAS_SSE2) vpx_idct16x16_256_add = vpx_idct16x16_256_add_sse2;
-    vpx_idct16x16_38_add = vpx_idct16x16_38_add_c;
-    if (flags & HAS_SSE2) vpx_idct16x16_38_add = vpx_idct16x16_38_add_sse2;
-    vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_c;
-    if (flags & HAS_SSE2) vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_sse2;
-    vpx_idct32x32_135_add = vpx_idct32x32_135_add_c;
-    if (flags & HAS_SSE2) vpx_idct32x32_135_add = vpx_idct32x32_1024_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct32x32_135_add = vpx_idct32x32_135_add_ssse3;
-    vpx_idct32x32_1_add = vpx_idct32x32_1_add_c;
-    if (flags & HAS_SSE2) vpx_idct32x32_1_add = vpx_idct32x32_1_add_sse2;
-    vpx_idct32x32_34_add = vpx_idct32x32_34_add_c;
-    if (flags & HAS_SSE2) vpx_idct32x32_34_add = vpx_idct32x32_34_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct32x32_34_add = vpx_idct32x32_34_add_ssse3;
-    vpx_idct4x4_16_add = vpx_idct4x4_16_add_c;
-    if (flags & HAS_SSE2) vpx_idct4x4_16_add = vpx_idct4x4_16_add_sse2;
-    vpx_idct4x4_1_add = vpx_idct4x4_1_add_c;
-    if (flags & HAS_SSE2) vpx_idct4x4_1_add = vpx_idct4x4_1_add_sse2;
-    vpx_idct8x8_12_add = vpx_idct8x8_12_add_c;
-    if (flags & HAS_SSE2) vpx_idct8x8_12_add = vpx_idct8x8_12_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct8x8_12_add = vpx_idct8x8_12_add_ssse3;
-    vpx_idct8x8_1_add = vpx_idct8x8_1_add_c;
-    if (flags & HAS_SSE2) vpx_idct8x8_1_add = vpx_idct8x8_1_add_sse2;
-    vpx_idct8x8_64_add = vpx_idct8x8_64_add_c;
-    if (flags & HAS_SSE2) vpx_idct8x8_64_add = vpx_idct8x8_64_add_sse2;
-    vpx_int_pro_col = vpx_int_pro_col_c;
-    if (flags & HAS_SSE2) vpx_int_pro_col = vpx_int_pro_col_sse2;
-    vpx_int_pro_row = vpx_int_pro_row_c;
-    if (flags & HAS_SSE2) vpx_int_pro_row = vpx_int_pro_row_sse2;
-    vpx_iwht4x4_16_add = vpx_iwht4x4_16_add_c;
-    if (flags & HAS_SSE2) vpx_iwht4x4_16_add = vpx_iwht4x4_16_add_sse2;
-    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_sse2;
-    if (flags & HAS_AVX2) vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_avx2;
-    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_sse2;
-    if (flags & HAS_AVX2) vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_avx2;
-    vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_sse2;
-    vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_sse2;
-    vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_sse2;
-    vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_sse2;
-    vpx_lpf_vertical_16 = vpx_lpf_vertical_16_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_16 = vpx_lpf_vertical_16_sse2;
-    vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_sse2;
-    vpx_lpf_vertical_4 = vpx_lpf_vertical_4_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_4 = vpx_lpf_vertical_4_sse2;
-    vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_sse2;
-    vpx_lpf_vertical_8 = vpx_lpf_vertical_8_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_8 = vpx_lpf_vertical_8_sse2;
-    vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_c;
-    if (flags & HAS_SSE2) vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_sse2;
-    vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_c;
-    if (flags & HAS_SSE2) vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_sse2;
-    vpx_mbpost_proc_down = vpx_mbpost_proc_down_c;
-    if (flags & HAS_SSE2) vpx_mbpost_proc_down = vpx_mbpost_proc_down_sse2;
-    vpx_minmax_8x8 = vpx_minmax_8x8_c;
-    if (flags & HAS_SSE2) vpx_minmax_8x8 = vpx_minmax_8x8_sse2;
-    vpx_mse16x16 = vpx_mse16x16_c;
-    if (flags & HAS_SSE2) vpx_mse16x16 = vpx_mse16x16_sse2;
-    if (flags & HAS_AVX2) vpx_mse16x16 = vpx_mse16x16_avx2;
-    vpx_mse16x8 = vpx_mse16x8_c;
-    if (flags & HAS_SSE2) vpx_mse16x8 = vpx_mse16x8_sse2;
-    vpx_mse8x16 = vpx_mse8x16_c;
-    if (flags & HAS_SSE2) vpx_mse8x16 = vpx_mse8x16_sse2;
-    vpx_mse8x8 = vpx_mse8x8_c;
-    if (flags & HAS_SSE2) vpx_mse8x8 = vpx_mse8x8_sse2;
-    vpx_plane_add_noise = vpx_plane_add_noise_c;
-    if (flags & HAS_SSE2) vpx_plane_add_noise = vpx_plane_add_noise_sse2;
-    vpx_post_proc_down_and_across_mb_row = vpx_post_proc_down_and_across_mb_row_c;
-    if (flags & HAS_SSE2) vpx_post_proc_down_and_across_mb_row = vpx_post_proc_down_and_across_mb_row_sse2;
-    vpx_quantize_b = vpx_quantize_b_c;
-    if (flags & HAS_SSE2) vpx_quantize_b = vpx_quantize_b_sse2;
-    vpx_sad16x16 = vpx_sad16x16_c;
-    if (flags & HAS_SSE2) vpx_sad16x16 = vpx_sad16x16_sse2;
-    vpx_sad16x16_avg = vpx_sad16x16_avg_c;
-    if (flags & HAS_SSE2) vpx_sad16x16_avg = vpx_sad16x16_avg_sse2;
-    vpx_sad16x16x3 = vpx_sad16x16x3_c;
-    if (flags & HAS_SSE3) vpx_sad16x16x3 = vpx_sad16x16x3_sse3;
-    if (flags & HAS_SSSE3) vpx_sad16x16x3 = vpx_sad16x16x3_ssse3;
-    vpx_sad16x16x4d = vpx_sad16x16x4d_c;
-    if (flags & HAS_SSE2) vpx_sad16x16x4d = vpx_sad16x16x4d_sse2;
-    vpx_sad16x16x8 = vpx_sad16x16x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad16x16x8 = vpx_sad16x16x8_sse4_1;
-    vpx_sad16x32 = vpx_sad16x32_c;
-    if (flags & HAS_SSE2) vpx_sad16x32 = vpx_sad16x32_sse2;
-    vpx_sad16x32_avg = vpx_sad16x32_avg_c;
-    if (flags & HAS_SSE2) vpx_sad16x32_avg = vpx_sad16x32_avg_sse2;
-    vpx_sad16x32x4d = vpx_sad16x32x4d_c;
-    if (flags & HAS_SSE2) vpx_sad16x32x4d = vpx_sad16x32x4d_sse2;
-    vpx_sad16x8 = vpx_sad16x8_c;
-    if (flags & HAS_SSE2) vpx_sad16x8 = vpx_sad16x8_sse2;
-    vpx_sad16x8_avg = vpx_sad16x8_avg_c;
-    if (flags & HAS_SSE2) vpx_sad16x8_avg = vpx_sad16x8_avg_sse2;
-    vpx_sad16x8x3 = vpx_sad16x8x3_c;
-    if (flags & HAS_SSE3) vpx_sad16x8x3 = vpx_sad16x8x3_sse3;
-    if (flags & HAS_SSSE3) vpx_sad16x8x3 = vpx_sad16x8x3_ssse3;
-    vpx_sad16x8x4d = vpx_sad16x8x4d_c;
-    if (flags & HAS_SSE2) vpx_sad16x8x4d = vpx_sad16x8x4d_sse2;
-    vpx_sad16x8x8 = vpx_sad16x8x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad16x8x8 = vpx_sad16x8x8_sse4_1;
-    vpx_sad32x16 = vpx_sad32x16_c;
-    if (flags & HAS_SSE2) vpx_sad32x16 = vpx_sad32x16_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x16 = vpx_sad32x16_avx2;
-    vpx_sad32x16_avg = vpx_sad32x16_avg_c;
-    if (flags & HAS_SSE2) vpx_sad32x16_avg = vpx_sad32x16_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x16_avg = vpx_sad32x16_avg_avx2;
-    vpx_sad32x16x4d = vpx_sad32x16x4d_c;
-    if (flags & HAS_SSE2) vpx_sad32x16x4d = vpx_sad32x16x4d_sse2;
-    vpx_sad32x32 = vpx_sad32x32_c;
-    if (flags & HAS_SSE2) vpx_sad32x32 = vpx_sad32x32_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32 = vpx_sad32x32_avx2;
-    vpx_sad32x32_avg = vpx_sad32x32_avg_c;
-    if (flags & HAS_SSE2) vpx_sad32x32_avg = vpx_sad32x32_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32_avg = vpx_sad32x32_avg_avx2;
-    vpx_sad32x32x4d = vpx_sad32x32x4d_c;
-    if (flags & HAS_SSE2) vpx_sad32x32x4d = vpx_sad32x32x4d_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32x4d = vpx_sad32x32x4d_avx2;
-    vpx_sad32x64 = vpx_sad32x64_c;
-    if (flags & HAS_SSE2) vpx_sad32x64 = vpx_sad32x64_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x64 = vpx_sad32x64_avx2;
-    vpx_sad32x64_avg = vpx_sad32x64_avg_c;
-    if (flags & HAS_SSE2) vpx_sad32x64_avg = vpx_sad32x64_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x64_avg = vpx_sad32x64_avg_avx2;
-    vpx_sad32x64x4d = vpx_sad32x64x4d_c;
-    if (flags & HAS_SSE2) vpx_sad32x64x4d = vpx_sad32x64x4d_sse2;
-    vpx_sad4x4 = vpx_sad4x4_c;
-    if (flags & HAS_SSE2) vpx_sad4x4 = vpx_sad4x4_sse2;
-    vpx_sad4x4_avg = vpx_sad4x4_avg_c;
-    if (flags & HAS_SSE2) vpx_sad4x4_avg = vpx_sad4x4_avg_sse2;
-    vpx_sad4x4x3 = vpx_sad4x4x3_c;
-    if (flags & HAS_SSE3) vpx_sad4x4x3 = vpx_sad4x4x3_sse3;
-    vpx_sad4x4x4d = vpx_sad4x4x4d_c;
-    if (flags & HAS_SSE2) vpx_sad4x4x4d = vpx_sad4x4x4d_sse2;
-    vpx_sad4x4x8 = vpx_sad4x4x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad4x4x8 = vpx_sad4x4x8_sse4_1;
-    vpx_sad4x8 = vpx_sad4x8_c;
-    if (flags & HAS_SSE2) vpx_sad4x8 = vpx_sad4x8_sse2;
-    vpx_sad4x8_avg = vpx_sad4x8_avg_c;
-    if (flags & HAS_SSE2) vpx_sad4x8_avg = vpx_sad4x8_avg_sse2;
-    vpx_sad4x8x4d = vpx_sad4x8x4d_c;
-    if (flags & HAS_SSE2) vpx_sad4x8x4d = vpx_sad4x8x4d_sse2;
-    vpx_sad64x32 = vpx_sad64x32_c;
-    if (flags & HAS_SSE2) vpx_sad64x32 = vpx_sad64x32_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x32 = vpx_sad64x32_avx2;
-    vpx_sad64x32_avg = vpx_sad64x32_avg_c;
-    if (flags & HAS_SSE2) vpx_sad64x32_avg = vpx_sad64x32_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x32_avg = vpx_sad64x32_avg_avx2;
-    vpx_sad64x32x4d = vpx_sad64x32x4d_c;
-    if (flags & HAS_SSE2) vpx_sad64x32x4d = vpx_sad64x32x4d_sse2;
-    vpx_sad64x64 = vpx_sad64x64_c;
-    if (flags & HAS_SSE2) vpx_sad64x64 = vpx_sad64x64_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64 = vpx_sad64x64_avx2;
-    vpx_sad64x64_avg = vpx_sad64x64_avg_c;
-    if (flags & HAS_SSE2) vpx_sad64x64_avg = vpx_sad64x64_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64_avg = vpx_sad64x64_avg_avx2;
-    vpx_sad64x64x4d = vpx_sad64x64x4d_c;
-    if (flags & HAS_SSE2) vpx_sad64x64x4d = vpx_sad64x64x4d_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64x4d = vpx_sad64x64x4d_avx2;
-    vpx_sad8x16 = vpx_sad8x16_c;
-    if (flags & HAS_SSE2) vpx_sad8x16 = vpx_sad8x16_sse2;
-    vpx_sad8x16_avg = vpx_sad8x16_avg_c;
-    if (flags & HAS_SSE2) vpx_sad8x16_avg = vpx_sad8x16_avg_sse2;
-    vpx_sad8x16x3 = vpx_sad8x16x3_c;
-    if (flags & HAS_SSE3) vpx_sad8x16x3 = vpx_sad8x16x3_sse3;
-    vpx_sad8x16x4d = vpx_sad8x16x4d_c;
-    if (flags & HAS_SSE2) vpx_sad8x16x4d = vpx_sad8x16x4d_sse2;
-    vpx_sad8x16x8 = vpx_sad8x16x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad8x16x8 = vpx_sad8x16x8_sse4_1;
-    vpx_sad8x4 = vpx_sad8x4_c;
-    if (flags & HAS_SSE2) vpx_sad8x4 = vpx_sad8x4_sse2;
-    vpx_sad8x4_avg = vpx_sad8x4_avg_c;
-    if (flags & HAS_SSE2) vpx_sad8x4_avg = vpx_sad8x4_avg_sse2;
-    vpx_sad8x4x4d = vpx_sad8x4x4d_c;
-    if (flags & HAS_SSE2) vpx_sad8x4x4d = vpx_sad8x4x4d_sse2;
-    vpx_sad8x8 = vpx_sad8x8_c;
-    if (flags & HAS_SSE2) vpx_sad8x8 = vpx_sad8x8_sse2;
-    vpx_sad8x8_avg = vpx_sad8x8_avg_c;
-    if (flags & HAS_SSE2) vpx_sad8x8_avg = vpx_sad8x8_avg_sse2;
-    vpx_sad8x8x3 = vpx_sad8x8x3_c;
-    if (flags & HAS_SSE3) vpx_sad8x8x3 = vpx_sad8x8x3_sse3;
-    vpx_sad8x8x4d = vpx_sad8x8x4d_c;
-    if (flags & HAS_SSE2) vpx_sad8x8x4d = vpx_sad8x8x4d_sse2;
-    vpx_sad8x8x8 = vpx_sad8x8x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad8x8x8 = vpx_sad8x8x8_sse4_1;
-    vpx_satd = vpx_satd_c;
-    if (flags & HAS_SSE2) vpx_satd = vpx_satd_sse2;
-    vpx_scaled_2d = vpx_scaled_2d_c;
-    if (flags & HAS_SSSE3) vpx_scaled_2d = vpx_scaled_2d_ssse3;
-    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_ssse3;
-    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_ssse3;
-    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_ssse3;
-    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_ssse3;
-    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_avx2;
-    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_ssse3;
-    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_ssse3;
-    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_ssse3;
-    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_ssse3;
-    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_avx2;
-    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_ssse3;
-    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_ssse3;
-    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_ssse3;
-    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_ssse3;
-    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_ssse3;
-    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_ssse3;
-    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_ssse3;
-    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_avx2;
-    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_ssse3;
-    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_ssse3;
-    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_ssse3;
-    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_ssse3;
-    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_avx2;
-    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_ssse3;
-    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_ssse3;
-    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_ssse3;
-    vpx_subtract_block = vpx_subtract_block_c;
-    if (flags & HAS_SSE2) vpx_subtract_block = vpx_subtract_block_sse2;
-    vpx_sum_squares_2d_i16 = vpx_sum_squares_2d_i16_c;
-    if (flags & HAS_SSE2) vpx_sum_squares_2d_i16 = vpx_sum_squares_2d_i16_sse2;
-    vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_sse2;
-    vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_sse2;
-    vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_sse2;
-    vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_sse2;
-    vpx_v_predictor_16x16 = vpx_v_predictor_16x16_c;
-    if (flags & HAS_SSE2) vpx_v_predictor_16x16 = vpx_v_predictor_16x16_sse2;
-    vpx_v_predictor_32x32 = vpx_v_predictor_32x32_c;
-    if (flags & HAS_SSE2) vpx_v_predictor_32x32 = vpx_v_predictor_32x32_sse2;
-    vpx_v_predictor_4x4 = vpx_v_predictor_4x4_c;
-    if (flags & HAS_SSE2) vpx_v_predictor_4x4 = vpx_v_predictor_4x4_sse2;
-    vpx_v_predictor_8x8 = vpx_v_predictor_8x8_c;
-    if (flags & HAS_SSE2) vpx_v_predictor_8x8 = vpx_v_predictor_8x8_sse2;
-    vpx_variance16x16 = vpx_variance16x16_c;
-    if (flags & HAS_SSE2) vpx_variance16x16 = vpx_variance16x16_sse2;
-    if (flags & HAS_AVX2) vpx_variance16x16 = vpx_variance16x16_avx2;
-    vpx_variance16x32 = vpx_variance16x32_c;
-    if (flags & HAS_SSE2) vpx_variance16x32 = vpx_variance16x32_sse2;
-    vpx_variance16x8 = vpx_variance16x8_c;
-    if (flags & HAS_SSE2) vpx_variance16x8 = vpx_variance16x8_sse2;
-    vpx_variance32x16 = vpx_variance32x16_c;
-    if (flags & HAS_SSE2) vpx_variance32x16 = vpx_variance32x16_sse2;
-    if (flags & HAS_AVX2) vpx_variance32x16 = vpx_variance32x16_avx2;
-    vpx_variance32x32 = vpx_variance32x32_c;
-    if (flags & HAS_SSE2) vpx_variance32x32 = vpx_variance32x32_sse2;
-    if (flags & HAS_AVX2) vpx_variance32x32 = vpx_variance32x32_avx2;
-    vpx_variance32x64 = vpx_variance32x64_c;
-    if (flags & HAS_SSE2) vpx_variance32x64 = vpx_variance32x64_sse2;
-    vpx_variance4x4 = vpx_variance4x4_c;
-    if (flags & HAS_SSE2) vpx_variance4x4 = vpx_variance4x4_sse2;
-    vpx_variance4x8 = vpx_variance4x8_c;
-    if (flags & HAS_SSE2) vpx_variance4x8 = vpx_variance4x8_sse2;
-    vpx_variance64x32 = vpx_variance64x32_c;
-    if (flags & HAS_SSE2) vpx_variance64x32 = vpx_variance64x32_sse2;
-    if (flags & HAS_AVX2) vpx_variance64x32 = vpx_variance64x32_avx2;
-    vpx_variance64x64 = vpx_variance64x64_c;
-    if (flags & HAS_SSE2) vpx_variance64x64 = vpx_variance64x64_sse2;
-    if (flags & HAS_AVX2) vpx_variance64x64 = vpx_variance64x64_avx2;
-    vpx_variance8x16 = vpx_variance8x16_c;
-    if (flags & HAS_SSE2) vpx_variance8x16 = vpx_variance8x16_sse2;
-    vpx_variance8x4 = vpx_variance8x4_c;
-    if (flags & HAS_SSE2) vpx_variance8x4 = vpx_variance8x4_sse2;
-    vpx_variance8x8 = vpx_variance8x8_c;
-    if (flags & HAS_SSE2) vpx_variance8x8 = vpx_variance8x8_sse2;
-    vpx_vector_var = vpx_vector_var_c;
-    if (flags & HAS_SSE2) vpx_vector_var = vpx_vector_var_sse2;
+  vpx_avg_4x4 = vpx_avg_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_avg_4x4 = vpx_avg_4x4_sse2;
+  vpx_avg_8x8 = vpx_avg_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_avg_8x8 = vpx_avg_8x8_sse2;
+  vpx_comp_avg_pred = vpx_comp_avg_pred_c;
+  if (flags & HAS_SSE2)
+    vpx_comp_avg_pred = vpx_comp_avg_pred_sse2;
+  vpx_convolve8 = vpx_convolve8_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8 = vpx_convolve8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8 = vpx_convolve8_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8 = vpx_convolve8_avx2;
+  vpx_convolve8_avg = vpx_convolve8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_avg = vpx_convolve8_avg_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg = vpx_convolve8_avg_ssse3;
+  vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_ssse3;
+  vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_ssse3;
+  vpx_convolve8_horiz = vpx_convolve8_horiz_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_avx2;
+  vpx_convolve8_vert = vpx_convolve8_vert_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve8_vert = vpx_convolve8_vert_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_vert = vpx_convolve8_vert_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8_vert = vpx_convolve8_vert_avx2;
+  vpx_convolve_avg = vpx_convolve_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve_avg = vpx_convolve_avg_sse2;
+  vpx_convolve_copy = vpx_convolve_copy_c;
+  if (flags & HAS_SSE2)
+    vpx_convolve_copy = vpx_convolve_copy_sse2;
+  vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_ssse3;
+  vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_ssse3;
+  vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_ssse3;
+  vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_ssse3;
+  vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_ssse3;
+  vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_ssse3;
+  vpx_d207_predictor_4x4 = vpx_d207_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_d207_predictor_4x4 = vpx_d207_predictor_4x4_sse2;
+  vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_ssse3;
+  vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_ssse3;
+  vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_ssse3;
+  vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_d45_predictor_4x4 = vpx_d45_predictor_4x4_sse2;
+  vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_d45_predictor_8x8 = vpx_d45_predictor_8x8_sse2;
+  vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_ssse3;
+  vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_ssse3;
+  vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_ssse3;
+  vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_ssse3;
+  vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_128_predictor_16x16 = vpx_dc_128_predictor_16x16_sse2;
+  vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_128_predictor_32x32 = vpx_dc_128_predictor_32x32_sse2;
+  vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_128_predictor_4x4 = vpx_dc_128_predictor_4x4_sse2;
+  vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_128_predictor_8x8 = vpx_dc_128_predictor_8x8_sse2;
+  vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_left_predictor_16x16 = vpx_dc_left_predictor_16x16_sse2;
+  vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_left_predictor_32x32 = vpx_dc_left_predictor_32x32_sse2;
+  vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_left_predictor_4x4 = vpx_dc_left_predictor_4x4_sse2;
+  vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_left_predictor_8x8 = vpx_dc_left_predictor_8x8_sse2;
+  vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_predictor_16x16 = vpx_dc_predictor_16x16_sse2;
+  vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_predictor_32x32 = vpx_dc_predictor_32x32_sse2;
+  vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_predictor_4x4 = vpx_dc_predictor_4x4_sse2;
+  vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_predictor_8x8 = vpx_dc_predictor_8x8_sse2;
+  vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_top_predictor_16x16 = vpx_dc_top_predictor_16x16_sse2;
+  vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_top_predictor_32x32 = vpx_dc_top_predictor_32x32_sse2;
+  vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_top_predictor_4x4 = vpx_dc_top_predictor_4x4_sse2;
+  vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_dc_top_predictor_8x8 = vpx_dc_top_predictor_8x8_sse2;
+  vpx_fdct16x16 = vpx_fdct16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct16x16 = vpx_fdct16x16_sse2;
+  vpx_fdct16x16_1 = vpx_fdct16x16_1_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct16x16_1 = vpx_fdct16x16_1_sse2;
+  vpx_fdct32x32 = vpx_fdct32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct32x32 = vpx_fdct32x32_sse2;
+  vpx_fdct32x32_1 = vpx_fdct32x32_1_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct32x32_1 = vpx_fdct32x32_1_sse2;
+  vpx_fdct32x32_rd = vpx_fdct32x32_rd_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct32x32_rd = vpx_fdct32x32_rd_sse2;
+  vpx_fdct4x4 = vpx_fdct4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct4x4 = vpx_fdct4x4_sse2;
+  vpx_fdct4x4_1 = vpx_fdct4x4_1_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct4x4_1 = vpx_fdct4x4_1_sse2;
+  vpx_fdct8x8 = vpx_fdct8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct8x8 = vpx_fdct8x8_sse2;
+  vpx_fdct8x8_1 = vpx_fdct8x8_1_c;
+  if (flags & HAS_SSE2)
+    vpx_fdct8x8_1 = vpx_fdct8x8_1_sse2;
+  vpx_get16x16var = vpx_get16x16var_c;
+  if (flags & HAS_SSE2)
+    vpx_get16x16var = vpx_get16x16var_sse2;
+  if (flags & HAS_AVX2)
+    vpx_get16x16var = vpx_get16x16var_avx2;
+  vpx_get8x8var = vpx_get8x8var_c;
+  if (flags & HAS_SSE2)
+    vpx_get8x8var = vpx_get8x8var_sse2;
+  vpx_get_mb_ss = vpx_get_mb_ss_c;
+  if (flags & HAS_SSE2)
+    vpx_get_mb_ss = vpx_get_mb_ss_sse2;
+  vpx_h_predictor_16x16 = vpx_h_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_h_predictor_16x16 = vpx_h_predictor_16x16_sse2;
+  vpx_h_predictor_32x32 = vpx_h_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_h_predictor_32x32 = vpx_h_predictor_32x32_sse2;
+  vpx_h_predictor_4x4 = vpx_h_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_h_predictor_4x4 = vpx_h_predictor_4x4_sse2;
+  vpx_h_predictor_8x8 = vpx_h_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_h_predictor_8x8 = vpx_h_predictor_8x8_sse2;
+  vpx_hadamard_16x16 = vpx_hadamard_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_hadamard_16x16 = vpx_hadamard_16x16_sse2;
+  vpx_hadamard_8x8 = vpx_hadamard_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_hadamard_8x8 = vpx_hadamard_8x8_sse2;
+  vpx_highbd_10_mse16x16 = vpx_highbd_10_mse16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_mse16x16 = vpx_highbd_10_mse16x16_sse2;
+  vpx_highbd_10_mse8x8 = vpx_highbd_10_mse8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_mse8x8 = vpx_highbd_10_mse8x8_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance16x16 =
+      vpx_highbd_10_sub_pixel_avg_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance16x16 =
+        vpx_highbd_10_sub_pixel_avg_variance16x16_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance16x32 =
+      vpx_highbd_10_sub_pixel_avg_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance16x32 =
+        vpx_highbd_10_sub_pixel_avg_variance16x32_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance16x8 =
+      vpx_highbd_10_sub_pixel_avg_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance16x8 =
+        vpx_highbd_10_sub_pixel_avg_variance16x8_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance32x16 =
+      vpx_highbd_10_sub_pixel_avg_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance32x16 =
+        vpx_highbd_10_sub_pixel_avg_variance32x16_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance32x32 =
+      vpx_highbd_10_sub_pixel_avg_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance32x32 =
+        vpx_highbd_10_sub_pixel_avg_variance32x32_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance32x64 =
+      vpx_highbd_10_sub_pixel_avg_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance32x64 =
+        vpx_highbd_10_sub_pixel_avg_variance32x64_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance64x32 =
+      vpx_highbd_10_sub_pixel_avg_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance64x32 =
+        vpx_highbd_10_sub_pixel_avg_variance64x32_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance64x64 =
+      vpx_highbd_10_sub_pixel_avg_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance64x64 =
+        vpx_highbd_10_sub_pixel_avg_variance64x64_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance8x16 =
+      vpx_highbd_10_sub_pixel_avg_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance8x16 =
+        vpx_highbd_10_sub_pixel_avg_variance8x16_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance8x4 =
+      vpx_highbd_10_sub_pixel_avg_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance8x4 =
+        vpx_highbd_10_sub_pixel_avg_variance8x4_sse2;
+  vpx_highbd_10_sub_pixel_avg_variance8x8 =
+      vpx_highbd_10_sub_pixel_avg_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_avg_variance8x8 =
+        vpx_highbd_10_sub_pixel_avg_variance8x8_sse2;
+  vpx_highbd_10_sub_pixel_variance16x16 =
+      vpx_highbd_10_sub_pixel_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance16x16 =
+        vpx_highbd_10_sub_pixel_variance16x16_sse2;
+  vpx_highbd_10_sub_pixel_variance16x32 =
+      vpx_highbd_10_sub_pixel_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance16x32 =
+        vpx_highbd_10_sub_pixel_variance16x32_sse2;
+  vpx_highbd_10_sub_pixel_variance16x8 = vpx_highbd_10_sub_pixel_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance16x8 =
+        vpx_highbd_10_sub_pixel_variance16x8_sse2;
+  vpx_highbd_10_sub_pixel_variance32x16 =
+      vpx_highbd_10_sub_pixel_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance32x16 =
+        vpx_highbd_10_sub_pixel_variance32x16_sse2;
+  vpx_highbd_10_sub_pixel_variance32x32 =
+      vpx_highbd_10_sub_pixel_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance32x32 =
+        vpx_highbd_10_sub_pixel_variance32x32_sse2;
+  vpx_highbd_10_sub_pixel_variance32x64 =
+      vpx_highbd_10_sub_pixel_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance32x64 =
+        vpx_highbd_10_sub_pixel_variance32x64_sse2;
+  vpx_highbd_10_sub_pixel_variance64x32 =
+      vpx_highbd_10_sub_pixel_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance64x32 =
+        vpx_highbd_10_sub_pixel_variance64x32_sse2;
+  vpx_highbd_10_sub_pixel_variance64x64 =
+      vpx_highbd_10_sub_pixel_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance64x64 =
+        vpx_highbd_10_sub_pixel_variance64x64_sse2;
+  vpx_highbd_10_sub_pixel_variance8x16 = vpx_highbd_10_sub_pixel_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance8x16 =
+        vpx_highbd_10_sub_pixel_variance8x16_sse2;
+  vpx_highbd_10_sub_pixel_variance8x4 = vpx_highbd_10_sub_pixel_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance8x4 =
+        vpx_highbd_10_sub_pixel_variance8x4_sse2;
+  vpx_highbd_10_sub_pixel_variance8x8 = vpx_highbd_10_sub_pixel_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_sub_pixel_variance8x8 =
+        vpx_highbd_10_sub_pixel_variance8x8_sse2;
+  vpx_highbd_10_variance16x16 = vpx_highbd_10_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance16x16 = vpx_highbd_10_variance16x16_sse2;
+  vpx_highbd_10_variance16x32 = vpx_highbd_10_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance16x32 = vpx_highbd_10_variance16x32_sse2;
+  vpx_highbd_10_variance16x8 = vpx_highbd_10_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance16x8 = vpx_highbd_10_variance16x8_sse2;
+  vpx_highbd_10_variance32x16 = vpx_highbd_10_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance32x16 = vpx_highbd_10_variance32x16_sse2;
+  vpx_highbd_10_variance32x32 = vpx_highbd_10_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance32x32 = vpx_highbd_10_variance32x32_sse2;
+  vpx_highbd_10_variance32x64 = vpx_highbd_10_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance32x64 = vpx_highbd_10_variance32x64_sse2;
+  vpx_highbd_10_variance64x32 = vpx_highbd_10_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance64x32 = vpx_highbd_10_variance64x32_sse2;
+  vpx_highbd_10_variance64x64 = vpx_highbd_10_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance64x64 = vpx_highbd_10_variance64x64_sse2;
+  vpx_highbd_10_variance8x16 = vpx_highbd_10_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance8x16 = vpx_highbd_10_variance8x16_sse2;
+  vpx_highbd_10_variance8x8 = vpx_highbd_10_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_10_variance8x8 = vpx_highbd_10_variance8x8_sse2;
+  vpx_highbd_12_mse16x16 = vpx_highbd_12_mse16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_mse16x16 = vpx_highbd_12_mse16x16_sse2;
+  vpx_highbd_12_mse8x8 = vpx_highbd_12_mse8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_mse8x8 = vpx_highbd_12_mse8x8_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance16x16 =
+      vpx_highbd_12_sub_pixel_avg_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance16x16 =
+        vpx_highbd_12_sub_pixel_avg_variance16x16_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance16x32 =
+      vpx_highbd_12_sub_pixel_avg_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance16x32 =
+        vpx_highbd_12_sub_pixel_avg_variance16x32_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance16x8 =
+      vpx_highbd_12_sub_pixel_avg_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance16x8 =
+        vpx_highbd_12_sub_pixel_avg_variance16x8_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance32x16 =
+      vpx_highbd_12_sub_pixel_avg_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance32x16 =
+        vpx_highbd_12_sub_pixel_avg_variance32x16_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance32x32 =
+      vpx_highbd_12_sub_pixel_avg_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance32x32 =
+        vpx_highbd_12_sub_pixel_avg_variance32x32_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance32x64 =
+      vpx_highbd_12_sub_pixel_avg_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance32x64 =
+        vpx_highbd_12_sub_pixel_avg_variance32x64_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance64x32 =
+      vpx_highbd_12_sub_pixel_avg_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance64x32 =
+        vpx_highbd_12_sub_pixel_avg_variance64x32_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance64x64 =
+      vpx_highbd_12_sub_pixel_avg_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance64x64 =
+        vpx_highbd_12_sub_pixel_avg_variance64x64_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance8x16 =
+      vpx_highbd_12_sub_pixel_avg_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance8x16 =
+        vpx_highbd_12_sub_pixel_avg_variance8x16_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance8x4 =
+      vpx_highbd_12_sub_pixel_avg_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance8x4 =
+        vpx_highbd_12_sub_pixel_avg_variance8x4_sse2;
+  vpx_highbd_12_sub_pixel_avg_variance8x8 =
+      vpx_highbd_12_sub_pixel_avg_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_avg_variance8x8 =
+        vpx_highbd_12_sub_pixel_avg_variance8x8_sse2;
+  vpx_highbd_12_sub_pixel_variance16x16 =
+      vpx_highbd_12_sub_pixel_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance16x16 =
+        vpx_highbd_12_sub_pixel_variance16x16_sse2;
+  vpx_highbd_12_sub_pixel_variance16x32 =
+      vpx_highbd_12_sub_pixel_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance16x32 =
+        vpx_highbd_12_sub_pixel_variance16x32_sse2;
+  vpx_highbd_12_sub_pixel_variance16x8 = vpx_highbd_12_sub_pixel_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance16x8 =
+        vpx_highbd_12_sub_pixel_variance16x8_sse2;
+  vpx_highbd_12_sub_pixel_variance32x16 =
+      vpx_highbd_12_sub_pixel_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance32x16 =
+        vpx_highbd_12_sub_pixel_variance32x16_sse2;
+  vpx_highbd_12_sub_pixel_variance32x32 =
+      vpx_highbd_12_sub_pixel_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance32x32 =
+        vpx_highbd_12_sub_pixel_variance32x32_sse2;
+  vpx_highbd_12_sub_pixel_variance32x64 =
+      vpx_highbd_12_sub_pixel_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance32x64 =
+        vpx_highbd_12_sub_pixel_variance32x64_sse2;
+  vpx_highbd_12_sub_pixel_variance64x32 =
+      vpx_highbd_12_sub_pixel_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance64x32 =
+        vpx_highbd_12_sub_pixel_variance64x32_sse2;
+  vpx_highbd_12_sub_pixel_variance64x64 =
+      vpx_highbd_12_sub_pixel_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance64x64 =
+        vpx_highbd_12_sub_pixel_variance64x64_sse2;
+  vpx_highbd_12_sub_pixel_variance8x16 = vpx_highbd_12_sub_pixel_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance8x16 =
+        vpx_highbd_12_sub_pixel_variance8x16_sse2;
+  vpx_highbd_12_sub_pixel_variance8x4 = vpx_highbd_12_sub_pixel_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance8x4 =
+        vpx_highbd_12_sub_pixel_variance8x4_sse2;
+  vpx_highbd_12_sub_pixel_variance8x8 = vpx_highbd_12_sub_pixel_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_sub_pixel_variance8x8 =
+        vpx_highbd_12_sub_pixel_variance8x8_sse2;
+  vpx_highbd_12_variance16x16 = vpx_highbd_12_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance16x16 = vpx_highbd_12_variance16x16_sse2;
+  vpx_highbd_12_variance16x32 = vpx_highbd_12_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance16x32 = vpx_highbd_12_variance16x32_sse2;
+  vpx_highbd_12_variance16x8 = vpx_highbd_12_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance16x8 = vpx_highbd_12_variance16x8_sse2;
+  vpx_highbd_12_variance32x16 = vpx_highbd_12_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance32x16 = vpx_highbd_12_variance32x16_sse2;
+  vpx_highbd_12_variance32x32 = vpx_highbd_12_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance32x32 = vpx_highbd_12_variance32x32_sse2;
+  vpx_highbd_12_variance32x64 = vpx_highbd_12_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance32x64 = vpx_highbd_12_variance32x64_sse2;
+  vpx_highbd_12_variance64x32 = vpx_highbd_12_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance64x32 = vpx_highbd_12_variance64x32_sse2;
+  vpx_highbd_12_variance64x64 = vpx_highbd_12_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance64x64 = vpx_highbd_12_variance64x64_sse2;
+  vpx_highbd_12_variance8x16 = vpx_highbd_12_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance8x16 = vpx_highbd_12_variance8x16_sse2;
+  vpx_highbd_12_variance8x8 = vpx_highbd_12_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_12_variance8x8 = vpx_highbd_12_variance8x8_sse2;
+  vpx_highbd_8_mse16x16 = vpx_highbd_8_mse16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_mse16x16 = vpx_highbd_8_mse16x16_sse2;
+  vpx_highbd_8_mse8x8 = vpx_highbd_8_mse8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_mse8x8 = vpx_highbd_8_mse8x8_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance16x16 =
+      vpx_highbd_8_sub_pixel_avg_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance16x16 =
+        vpx_highbd_8_sub_pixel_avg_variance16x16_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance16x32 =
+      vpx_highbd_8_sub_pixel_avg_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance16x32 =
+        vpx_highbd_8_sub_pixel_avg_variance16x32_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance16x8 =
+      vpx_highbd_8_sub_pixel_avg_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance16x8 =
+        vpx_highbd_8_sub_pixel_avg_variance16x8_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance32x16 =
+      vpx_highbd_8_sub_pixel_avg_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance32x16 =
+        vpx_highbd_8_sub_pixel_avg_variance32x16_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance32x32 =
+      vpx_highbd_8_sub_pixel_avg_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance32x32 =
+        vpx_highbd_8_sub_pixel_avg_variance32x32_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance32x64 =
+      vpx_highbd_8_sub_pixel_avg_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance32x64 =
+        vpx_highbd_8_sub_pixel_avg_variance32x64_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance64x32 =
+      vpx_highbd_8_sub_pixel_avg_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance64x32 =
+        vpx_highbd_8_sub_pixel_avg_variance64x32_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance64x64 =
+      vpx_highbd_8_sub_pixel_avg_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance64x64 =
+        vpx_highbd_8_sub_pixel_avg_variance64x64_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance8x16 =
+      vpx_highbd_8_sub_pixel_avg_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance8x16 =
+        vpx_highbd_8_sub_pixel_avg_variance8x16_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance8x4 =
+      vpx_highbd_8_sub_pixel_avg_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance8x4 =
+        vpx_highbd_8_sub_pixel_avg_variance8x4_sse2;
+  vpx_highbd_8_sub_pixel_avg_variance8x8 =
+      vpx_highbd_8_sub_pixel_avg_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_avg_variance8x8 =
+        vpx_highbd_8_sub_pixel_avg_variance8x8_sse2;
+  vpx_highbd_8_sub_pixel_variance16x16 = vpx_highbd_8_sub_pixel_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance16x16 =
+        vpx_highbd_8_sub_pixel_variance16x16_sse2;
+  vpx_highbd_8_sub_pixel_variance16x32 = vpx_highbd_8_sub_pixel_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance16x32 =
+        vpx_highbd_8_sub_pixel_variance16x32_sse2;
+  vpx_highbd_8_sub_pixel_variance16x8 = vpx_highbd_8_sub_pixel_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance16x8 =
+        vpx_highbd_8_sub_pixel_variance16x8_sse2;
+  vpx_highbd_8_sub_pixel_variance32x16 = vpx_highbd_8_sub_pixel_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance32x16 =
+        vpx_highbd_8_sub_pixel_variance32x16_sse2;
+  vpx_highbd_8_sub_pixel_variance32x32 = vpx_highbd_8_sub_pixel_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance32x32 =
+        vpx_highbd_8_sub_pixel_variance32x32_sse2;
+  vpx_highbd_8_sub_pixel_variance32x64 = vpx_highbd_8_sub_pixel_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance32x64 =
+        vpx_highbd_8_sub_pixel_variance32x64_sse2;
+  vpx_highbd_8_sub_pixel_variance64x32 = vpx_highbd_8_sub_pixel_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance64x32 =
+        vpx_highbd_8_sub_pixel_variance64x32_sse2;
+  vpx_highbd_8_sub_pixel_variance64x64 = vpx_highbd_8_sub_pixel_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance64x64 =
+        vpx_highbd_8_sub_pixel_variance64x64_sse2;
+  vpx_highbd_8_sub_pixel_variance8x16 = vpx_highbd_8_sub_pixel_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance8x16 =
+        vpx_highbd_8_sub_pixel_variance8x16_sse2;
+  vpx_highbd_8_sub_pixel_variance8x4 = vpx_highbd_8_sub_pixel_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance8x4 =
+        vpx_highbd_8_sub_pixel_variance8x4_sse2;
+  vpx_highbd_8_sub_pixel_variance8x8 = vpx_highbd_8_sub_pixel_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_sub_pixel_variance8x8 =
+        vpx_highbd_8_sub_pixel_variance8x8_sse2;
+  vpx_highbd_8_variance16x16 = vpx_highbd_8_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance16x16 = vpx_highbd_8_variance16x16_sse2;
+  vpx_highbd_8_variance16x32 = vpx_highbd_8_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance16x32 = vpx_highbd_8_variance16x32_sse2;
+  vpx_highbd_8_variance16x8 = vpx_highbd_8_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance16x8 = vpx_highbd_8_variance16x8_sse2;
+  vpx_highbd_8_variance32x16 = vpx_highbd_8_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance32x16 = vpx_highbd_8_variance32x16_sse2;
+  vpx_highbd_8_variance32x32 = vpx_highbd_8_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance32x32 = vpx_highbd_8_variance32x32_sse2;
+  vpx_highbd_8_variance32x64 = vpx_highbd_8_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance32x64 = vpx_highbd_8_variance32x64_sse2;
+  vpx_highbd_8_variance64x32 = vpx_highbd_8_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance64x32 = vpx_highbd_8_variance64x32_sse2;
+  vpx_highbd_8_variance64x64 = vpx_highbd_8_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance64x64 = vpx_highbd_8_variance64x64_sse2;
+  vpx_highbd_8_variance8x16 = vpx_highbd_8_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance8x16 = vpx_highbd_8_variance8x16_sse2;
+  vpx_highbd_8_variance8x8 = vpx_highbd_8_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_8_variance8x8 = vpx_highbd_8_variance8x8_sse2;
+  vpx_highbd_convolve8 = vpx_highbd_convolve8_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8 = vpx_highbd_convolve8_avx2;
+  vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_avx2;
+  vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_avx2;
+  vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_avx2;
+  vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_avx2;
+  vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_c;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_avx2;
+  vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_avx2;
+  vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_avx2;
+  vpx_highbd_dc_predictor_16x16 = vpx_highbd_dc_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_dc_predictor_16x16 = vpx_highbd_dc_predictor_16x16_sse2;
+  vpx_highbd_dc_predictor_32x32 = vpx_highbd_dc_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_dc_predictor_32x32 = vpx_highbd_dc_predictor_32x32_sse2;
+  vpx_highbd_dc_predictor_4x4 = vpx_highbd_dc_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_dc_predictor_4x4 = vpx_highbd_dc_predictor_4x4_sse2;
+  vpx_highbd_dc_predictor_8x8 = vpx_highbd_dc_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_dc_predictor_8x8 = vpx_highbd_dc_predictor_8x8_sse2;
+  vpx_highbd_fdct16x16 = vpx_highbd_fdct16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct16x16 = vpx_highbd_fdct16x16_sse2;
+  vpx_highbd_fdct32x32 = vpx_highbd_fdct32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct32x32 = vpx_highbd_fdct32x32_sse2;
+  vpx_highbd_fdct32x32_rd = vpx_highbd_fdct32x32_rd_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct32x32_rd = vpx_highbd_fdct32x32_rd_sse2;
+  vpx_highbd_fdct4x4 = vpx_highbd_fdct4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct4x4 = vpx_highbd_fdct4x4_sse2;
+  vpx_highbd_fdct8x8 = vpx_highbd_fdct8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_fdct8x8 = vpx_highbd_fdct8x8_sse2;
+  vpx_highbd_idct16x16_10_add = vpx_highbd_idct16x16_10_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct16x16_10_add = vpx_highbd_idct16x16_10_add_sse2;
+  vpx_highbd_idct16x16_1_add = vpx_highbd_idct16x16_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct16x16_1_add = vpx_highbd_idct16x16_1_add_sse2;
+  vpx_highbd_idct16x16_256_add = vpx_highbd_idct16x16_256_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct16x16_256_add = vpx_highbd_idct16x16_256_add_sse2;
+  vpx_highbd_idct16x16_38_add = vpx_highbd_idct16x16_38_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct16x16_38_add = vpx_highbd_idct16x16_38_add_sse2;
+  vpx_highbd_idct32x32_1_add = vpx_highbd_idct32x32_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct32x32_1_add = vpx_highbd_idct32x32_1_add_sse2;
+  vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse4_1;
+  vpx_highbd_idct4x4_1_add = vpx_highbd_idct4x4_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct4x4_1_add = vpx_highbd_idct4x4_1_add_sse2;
+  vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse4_1;
+  vpx_highbd_idct8x8_1_add = vpx_highbd_idct8x8_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct8x8_1_add = vpx_highbd_idct8x8_1_add_sse2;
+  vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse4_1;
+  vpx_highbd_lpf_horizontal_16 = vpx_highbd_lpf_horizontal_16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_16 = vpx_highbd_lpf_horizontal_16_sse2;
+  vpx_highbd_lpf_horizontal_16_dual = vpx_highbd_lpf_horizontal_16_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_16_dual = vpx_highbd_lpf_horizontal_16_dual_sse2;
+  vpx_highbd_lpf_horizontal_4 = vpx_highbd_lpf_horizontal_4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_4 = vpx_highbd_lpf_horizontal_4_sse2;
+  vpx_highbd_lpf_horizontal_4_dual = vpx_highbd_lpf_horizontal_4_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_4_dual = vpx_highbd_lpf_horizontal_4_dual_sse2;
+  vpx_highbd_lpf_horizontal_8 = vpx_highbd_lpf_horizontal_8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_8 = vpx_highbd_lpf_horizontal_8_sse2;
+  vpx_highbd_lpf_horizontal_8_dual = vpx_highbd_lpf_horizontal_8_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_horizontal_8_dual = vpx_highbd_lpf_horizontal_8_dual_sse2;
+  vpx_highbd_lpf_vertical_16 = vpx_highbd_lpf_vertical_16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_16 = vpx_highbd_lpf_vertical_16_sse2;
+  vpx_highbd_lpf_vertical_16_dual = vpx_highbd_lpf_vertical_16_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_16_dual = vpx_highbd_lpf_vertical_16_dual_sse2;
+  vpx_highbd_lpf_vertical_4 = vpx_highbd_lpf_vertical_4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_4 = vpx_highbd_lpf_vertical_4_sse2;
+  vpx_highbd_lpf_vertical_4_dual = vpx_highbd_lpf_vertical_4_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_4_dual = vpx_highbd_lpf_vertical_4_dual_sse2;
+  vpx_highbd_lpf_vertical_8 = vpx_highbd_lpf_vertical_8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_8 = vpx_highbd_lpf_vertical_8_sse2;
+  vpx_highbd_lpf_vertical_8_dual = vpx_highbd_lpf_vertical_8_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_lpf_vertical_8_dual = vpx_highbd_lpf_vertical_8_dual_sse2;
+  vpx_highbd_quantize_b = vpx_highbd_quantize_b_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_quantize_b = vpx_highbd_quantize_b_sse2;
+  vpx_highbd_quantize_b_32x32 = vpx_highbd_quantize_b_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_quantize_b_32x32 = vpx_highbd_quantize_b_32x32_sse2;
+  vpx_highbd_sad16x16 = vpx_highbd_sad16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x16 = vpx_highbd_sad16x16_sse2;
+  vpx_highbd_sad16x16_avg = vpx_highbd_sad16x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x16_avg = vpx_highbd_sad16x16_avg_sse2;
+  vpx_highbd_sad16x16x4d = vpx_highbd_sad16x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x16x4d = vpx_highbd_sad16x16x4d_sse2;
+  vpx_highbd_sad16x32 = vpx_highbd_sad16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x32 = vpx_highbd_sad16x32_sse2;
+  vpx_highbd_sad16x32_avg = vpx_highbd_sad16x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x32_avg = vpx_highbd_sad16x32_avg_sse2;
+  vpx_highbd_sad16x32x4d = vpx_highbd_sad16x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x32x4d = vpx_highbd_sad16x32x4d_sse2;
+  vpx_highbd_sad16x8 = vpx_highbd_sad16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x8 = vpx_highbd_sad16x8_sse2;
+  vpx_highbd_sad16x8_avg = vpx_highbd_sad16x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x8_avg = vpx_highbd_sad16x8_avg_sse2;
+  vpx_highbd_sad16x8x4d = vpx_highbd_sad16x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad16x8x4d = vpx_highbd_sad16x8x4d_sse2;
+  vpx_highbd_sad32x16 = vpx_highbd_sad32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x16 = vpx_highbd_sad32x16_sse2;
+  vpx_highbd_sad32x16_avg = vpx_highbd_sad32x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x16_avg = vpx_highbd_sad32x16_avg_sse2;
+  vpx_highbd_sad32x16x4d = vpx_highbd_sad32x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x16x4d = vpx_highbd_sad32x16x4d_sse2;
+  vpx_highbd_sad32x32 = vpx_highbd_sad32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x32 = vpx_highbd_sad32x32_sse2;
+  vpx_highbd_sad32x32_avg = vpx_highbd_sad32x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x32_avg = vpx_highbd_sad32x32_avg_sse2;
+  vpx_highbd_sad32x32x4d = vpx_highbd_sad32x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x32x4d = vpx_highbd_sad32x32x4d_sse2;
+  vpx_highbd_sad32x64 = vpx_highbd_sad32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x64 = vpx_highbd_sad32x64_sse2;
+  vpx_highbd_sad32x64_avg = vpx_highbd_sad32x64_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x64_avg = vpx_highbd_sad32x64_avg_sse2;
+  vpx_highbd_sad32x64x4d = vpx_highbd_sad32x64x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad32x64x4d = vpx_highbd_sad32x64x4d_sse2;
+  vpx_highbd_sad4x4x4d = vpx_highbd_sad4x4x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad4x4x4d = vpx_highbd_sad4x4x4d_sse2;
+  vpx_highbd_sad4x8x4d = vpx_highbd_sad4x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad4x8x4d = vpx_highbd_sad4x8x4d_sse2;
+  vpx_highbd_sad64x32 = vpx_highbd_sad64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x32 = vpx_highbd_sad64x32_sse2;
+  vpx_highbd_sad64x32_avg = vpx_highbd_sad64x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x32_avg = vpx_highbd_sad64x32_avg_sse2;
+  vpx_highbd_sad64x32x4d = vpx_highbd_sad64x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x32x4d = vpx_highbd_sad64x32x4d_sse2;
+  vpx_highbd_sad64x64 = vpx_highbd_sad64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x64 = vpx_highbd_sad64x64_sse2;
+  vpx_highbd_sad64x64_avg = vpx_highbd_sad64x64_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x64_avg = vpx_highbd_sad64x64_avg_sse2;
+  vpx_highbd_sad64x64x4d = vpx_highbd_sad64x64x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad64x64x4d = vpx_highbd_sad64x64x4d_sse2;
+  vpx_highbd_sad8x16 = vpx_highbd_sad8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x16 = vpx_highbd_sad8x16_sse2;
+  vpx_highbd_sad8x16_avg = vpx_highbd_sad8x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x16_avg = vpx_highbd_sad8x16_avg_sse2;
+  vpx_highbd_sad8x16x4d = vpx_highbd_sad8x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x16x4d = vpx_highbd_sad8x16x4d_sse2;
+  vpx_highbd_sad8x4 = vpx_highbd_sad8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x4 = vpx_highbd_sad8x4_sse2;
+  vpx_highbd_sad8x4_avg = vpx_highbd_sad8x4_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x4_avg = vpx_highbd_sad8x4_avg_sse2;
+  vpx_highbd_sad8x4x4d = vpx_highbd_sad8x4x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x4x4d = vpx_highbd_sad8x4x4d_sse2;
+  vpx_highbd_sad8x8 = vpx_highbd_sad8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x8 = vpx_highbd_sad8x8_sse2;
+  vpx_highbd_sad8x8_avg = vpx_highbd_sad8x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x8_avg = vpx_highbd_sad8x8_avg_sse2;
+  vpx_highbd_sad8x8x4d = vpx_highbd_sad8x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_sad8x8x4d = vpx_highbd_sad8x8x4d_sse2;
+  vpx_highbd_tm_predictor_16x16 = vpx_highbd_tm_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_tm_predictor_16x16 = vpx_highbd_tm_predictor_16x16_sse2;
+  vpx_highbd_tm_predictor_32x32 = vpx_highbd_tm_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_tm_predictor_32x32 = vpx_highbd_tm_predictor_32x32_sse2;
+  vpx_highbd_tm_predictor_4x4 = vpx_highbd_tm_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_tm_predictor_4x4 = vpx_highbd_tm_predictor_4x4_sse2;
+  vpx_highbd_tm_predictor_8x8 = vpx_highbd_tm_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_tm_predictor_8x8 = vpx_highbd_tm_predictor_8x8_sse2;
+  vpx_highbd_v_predictor_16x16 = vpx_highbd_v_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_v_predictor_16x16 = vpx_highbd_v_predictor_16x16_sse2;
+  vpx_highbd_v_predictor_32x32 = vpx_highbd_v_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_v_predictor_32x32 = vpx_highbd_v_predictor_32x32_sse2;
+  vpx_highbd_v_predictor_4x4 = vpx_highbd_v_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_v_predictor_4x4 = vpx_highbd_v_predictor_4x4_sse2;
+  vpx_highbd_v_predictor_8x8 = vpx_highbd_v_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_highbd_v_predictor_8x8 = vpx_highbd_v_predictor_8x8_sse2;
+  vpx_idct16x16_10_add = vpx_idct16x16_10_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct16x16_10_add = vpx_idct16x16_10_add_sse2;
+  vpx_idct16x16_1_add = vpx_idct16x16_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct16x16_1_add = vpx_idct16x16_1_add_sse2;
+  vpx_idct16x16_256_add = vpx_idct16x16_256_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct16x16_256_add = vpx_idct16x16_256_add_sse2;
+  vpx_idct16x16_38_add = vpx_idct16x16_38_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct16x16_38_add = vpx_idct16x16_38_add_sse2;
+  vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct32x32_1024_add = vpx_idct32x32_1024_add_sse2;
+  vpx_idct32x32_135_add = vpx_idct32x32_135_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct32x32_135_add = vpx_idct32x32_1024_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct32x32_135_add = vpx_idct32x32_135_add_ssse3;
+  vpx_idct32x32_1_add = vpx_idct32x32_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct32x32_1_add = vpx_idct32x32_1_add_sse2;
+  vpx_idct32x32_34_add = vpx_idct32x32_34_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct32x32_34_add = vpx_idct32x32_34_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct32x32_34_add = vpx_idct32x32_34_add_ssse3;
+  vpx_idct4x4_16_add = vpx_idct4x4_16_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct4x4_16_add = vpx_idct4x4_16_add_sse2;
+  vpx_idct4x4_1_add = vpx_idct4x4_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct4x4_1_add = vpx_idct4x4_1_add_sse2;
+  vpx_idct8x8_12_add = vpx_idct8x8_12_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct8x8_12_add = vpx_idct8x8_12_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct8x8_12_add = vpx_idct8x8_12_add_ssse3;
+  vpx_idct8x8_1_add = vpx_idct8x8_1_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct8x8_1_add = vpx_idct8x8_1_add_sse2;
+  vpx_idct8x8_64_add = vpx_idct8x8_64_add_c;
+  if (flags & HAS_SSE2)
+    vpx_idct8x8_64_add = vpx_idct8x8_64_add_sse2;
+  vpx_int_pro_col = vpx_int_pro_col_c;
+  if (flags & HAS_SSE2)
+    vpx_int_pro_col = vpx_int_pro_col_sse2;
+  vpx_int_pro_row = vpx_int_pro_row_c;
+  if (flags & HAS_SSE2)
+    vpx_int_pro_row = vpx_int_pro_row_sse2;
+  vpx_iwht4x4_16_add = vpx_iwht4x4_16_add_c;
+  if (flags & HAS_SSE2)
+    vpx_iwht4x4_16_add = vpx_iwht4x4_16_add_sse2;
+  vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_avx2;
+  vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_sse2;
+  if (flags & HAS_AVX2)
+    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_avx2;
+  vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_4 = vpx_lpf_horizontal_4_sse2;
+  vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_4_dual = vpx_lpf_horizontal_4_dual_sse2;
+  vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_8 = vpx_lpf_horizontal_8_sse2;
+  vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_horizontal_8_dual = vpx_lpf_horizontal_8_dual_sse2;
+  vpx_lpf_vertical_16 = vpx_lpf_vertical_16_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_16 = vpx_lpf_vertical_16_sse2;
+  vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_16_dual = vpx_lpf_vertical_16_dual_sse2;
+  vpx_lpf_vertical_4 = vpx_lpf_vertical_4_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_4 = vpx_lpf_vertical_4_sse2;
+  vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_4_dual = vpx_lpf_vertical_4_dual_sse2;
+  vpx_lpf_vertical_8 = vpx_lpf_vertical_8_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_8 = vpx_lpf_vertical_8_sse2;
+  vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_c;
+  if (flags & HAS_SSE2)
+    vpx_lpf_vertical_8_dual = vpx_lpf_vertical_8_dual_sse2;
+  vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_c;
+  if (flags & HAS_SSE2)
+    vpx_mbpost_proc_across_ip = vpx_mbpost_proc_across_ip_sse2;
+  vpx_mbpost_proc_down = vpx_mbpost_proc_down_c;
+  if (flags & HAS_SSE2)
+    vpx_mbpost_proc_down = vpx_mbpost_proc_down_sse2;
+  vpx_minmax_8x8 = vpx_minmax_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_minmax_8x8 = vpx_minmax_8x8_sse2;
+  vpx_mse16x16 = vpx_mse16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_mse16x16 = vpx_mse16x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_mse16x16 = vpx_mse16x16_avx2;
+  vpx_mse16x8 = vpx_mse16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_mse16x8 = vpx_mse16x8_sse2;
+  vpx_mse8x16 = vpx_mse8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_mse8x16 = vpx_mse8x16_sse2;
+  vpx_mse8x8 = vpx_mse8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_mse8x8 = vpx_mse8x8_sse2;
+  vpx_plane_add_noise = vpx_plane_add_noise_c;
+  if (flags & HAS_SSE2)
+    vpx_plane_add_noise = vpx_plane_add_noise_sse2;
+  vpx_post_proc_down_and_across_mb_row = vpx_post_proc_down_and_across_mb_row_c;
+  if (flags & HAS_SSE2)
+    vpx_post_proc_down_and_across_mb_row =
+        vpx_post_proc_down_and_across_mb_row_sse2;
+  vpx_quantize_b = vpx_quantize_b_c;
+  if (flags & HAS_SSE2)
+    vpx_quantize_b = vpx_quantize_b_sse2;
+  vpx_sad16x16 = vpx_sad16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x16 = vpx_sad16x16_sse2;
+  vpx_sad16x16_avg = vpx_sad16x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x16_avg = vpx_sad16x16_avg_sse2;
+  vpx_sad16x16x3 = vpx_sad16x16x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad16x16x3 = vpx_sad16x16x3_sse3;
+  if (flags & HAS_SSSE3)
+    vpx_sad16x16x3 = vpx_sad16x16x3_ssse3;
+  vpx_sad16x16x4d = vpx_sad16x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x16x4d = vpx_sad16x16x4d_sse2;
+  vpx_sad16x16x8 = vpx_sad16x16x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad16x16x8 = vpx_sad16x16x8_sse4_1;
+  vpx_sad16x32 = vpx_sad16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x32 = vpx_sad16x32_sse2;
+  vpx_sad16x32_avg = vpx_sad16x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x32_avg = vpx_sad16x32_avg_sse2;
+  vpx_sad16x32x4d = vpx_sad16x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x32x4d = vpx_sad16x32x4d_sse2;
+  vpx_sad16x8 = vpx_sad16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x8 = vpx_sad16x8_sse2;
+  vpx_sad16x8_avg = vpx_sad16x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x8_avg = vpx_sad16x8_avg_sse2;
+  vpx_sad16x8x3 = vpx_sad16x8x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad16x8x3 = vpx_sad16x8x3_sse3;
+  if (flags & HAS_SSSE3)
+    vpx_sad16x8x3 = vpx_sad16x8x3_ssse3;
+  vpx_sad16x8x4d = vpx_sad16x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad16x8x4d = vpx_sad16x8x4d_sse2;
+  vpx_sad16x8x8 = vpx_sad16x8x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad16x8x8 = vpx_sad16x8x8_sse4_1;
+  vpx_sad32x16 = vpx_sad32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x16 = vpx_sad32x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x16 = vpx_sad32x16_avx2;
+  vpx_sad32x16_avg = vpx_sad32x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x16_avg = vpx_sad32x16_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x16_avg = vpx_sad32x16_avg_avx2;
+  vpx_sad32x16x4d = vpx_sad32x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x16x4d = vpx_sad32x16x4d_sse2;
+  vpx_sad32x32 = vpx_sad32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x32 = vpx_sad32x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32 = vpx_sad32x32_avx2;
+  vpx_sad32x32_avg = vpx_sad32x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x32_avg = vpx_sad32x32_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32_avg = vpx_sad32x32_avg_avx2;
+  vpx_sad32x32x4d = vpx_sad32x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x32x4d = vpx_sad32x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32x4d = vpx_sad32x32x4d_avx2;
+  vpx_sad32x64 = vpx_sad32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x64 = vpx_sad32x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x64 = vpx_sad32x64_avx2;
+  vpx_sad32x64_avg = vpx_sad32x64_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x64_avg = vpx_sad32x64_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x64_avg = vpx_sad32x64_avg_avx2;
+  vpx_sad32x64x4d = vpx_sad32x64x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad32x64x4d = vpx_sad32x64x4d_sse2;
+  vpx_sad4x4 = vpx_sad4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x4 = vpx_sad4x4_sse2;
+  vpx_sad4x4_avg = vpx_sad4x4_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x4_avg = vpx_sad4x4_avg_sse2;
+  vpx_sad4x4x3 = vpx_sad4x4x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad4x4x3 = vpx_sad4x4x3_sse3;
+  vpx_sad4x4x4d = vpx_sad4x4x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x4x4d = vpx_sad4x4x4d_sse2;
+  vpx_sad4x4x8 = vpx_sad4x4x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad4x4x8 = vpx_sad4x4x8_sse4_1;
+  vpx_sad4x8 = vpx_sad4x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x8 = vpx_sad4x8_sse2;
+  vpx_sad4x8_avg = vpx_sad4x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x8_avg = vpx_sad4x8_avg_sse2;
+  vpx_sad4x8x4d = vpx_sad4x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad4x8x4d = vpx_sad4x8x4d_sse2;
+  vpx_sad64x32 = vpx_sad64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x32 = vpx_sad64x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x32 = vpx_sad64x32_avx2;
+  vpx_sad64x32_avg = vpx_sad64x32_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x32_avg = vpx_sad64x32_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x32_avg = vpx_sad64x32_avg_avx2;
+  vpx_sad64x32x4d = vpx_sad64x32x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x32x4d = vpx_sad64x32x4d_sse2;
+  vpx_sad64x64 = vpx_sad64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x64 = vpx_sad64x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64 = vpx_sad64x64_avx2;
+  vpx_sad64x64_avg = vpx_sad64x64_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x64_avg = vpx_sad64x64_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64_avg = vpx_sad64x64_avg_avx2;
+  vpx_sad64x64x4d = vpx_sad64x64x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad64x64x4d = vpx_sad64x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64x4d = vpx_sad64x64x4d_avx2;
+  vpx_sad8x16 = vpx_sad8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x16 = vpx_sad8x16_sse2;
+  vpx_sad8x16_avg = vpx_sad8x16_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x16_avg = vpx_sad8x16_avg_sse2;
+  vpx_sad8x16x3 = vpx_sad8x16x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad8x16x3 = vpx_sad8x16x3_sse3;
+  vpx_sad8x16x4d = vpx_sad8x16x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x16x4d = vpx_sad8x16x4d_sse2;
+  vpx_sad8x16x8 = vpx_sad8x16x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad8x16x8 = vpx_sad8x16x8_sse4_1;
+  vpx_sad8x4 = vpx_sad8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x4 = vpx_sad8x4_sse2;
+  vpx_sad8x4_avg = vpx_sad8x4_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x4_avg = vpx_sad8x4_avg_sse2;
+  vpx_sad8x4x4d = vpx_sad8x4x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x4x4d = vpx_sad8x4x4d_sse2;
+  vpx_sad8x8 = vpx_sad8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x8 = vpx_sad8x8_sse2;
+  vpx_sad8x8_avg = vpx_sad8x8_avg_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x8_avg = vpx_sad8x8_avg_sse2;
+  vpx_sad8x8x3 = vpx_sad8x8x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad8x8x3 = vpx_sad8x8x3_sse3;
+  vpx_sad8x8x4d = vpx_sad8x8x4d_c;
+  if (flags & HAS_SSE2)
+    vpx_sad8x8x4d = vpx_sad8x8x4d_sse2;
+  vpx_sad8x8x8 = vpx_sad8x8x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad8x8x8 = vpx_sad8x8x8_sse4_1;
+  vpx_satd = vpx_satd_c;
+  if (flags & HAS_SSE2)
+    vpx_satd = vpx_satd_sse2;
+  vpx_scaled_2d = vpx_scaled_2d_c;
+  if (flags & HAS_SSSE3)
+    vpx_scaled_2d = vpx_scaled_2d_ssse3;
+  vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_ssse3;
+  vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_ssse3;
+  vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_ssse3;
+  vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_ssse3;
+  vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_avx2;
+  vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_ssse3;
+  vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_ssse3;
+  vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_ssse3;
+  vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_ssse3;
+  vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_avx2;
+  vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_ssse3;
+  vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_ssse3;
+  vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_ssse3;
+  vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_ssse3;
+  vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_ssse3;
+  vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_ssse3;
+  vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_ssse3;
+  vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_avx2;
+  vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_ssse3;
+  vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_ssse3;
+  vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_ssse3;
+  vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_ssse3;
+  vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_avx2;
+  vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_ssse3;
+  vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_ssse3;
+  vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_ssse3;
+  vpx_subtract_block = vpx_subtract_block_c;
+  if (flags & HAS_SSE2)
+    vpx_subtract_block = vpx_subtract_block_sse2;
+  vpx_sum_squares_2d_i16 = vpx_sum_squares_2d_i16_c;
+  if (flags & HAS_SSE2)
+    vpx_sum_squares_2d_i16 = vpx_sum_squares_2d_i16_sse2;
+  vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_tm_predictor_16x16 = vpx_tm_predictor_16x16_sse2;
+  vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_tm_predictor_32x32 = vpx_tm_predictor_32x32_sse2;
+  vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_tm_predictor_4x4 = vpx_tm_predictor_4x4_sse2;
+  vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_tm_predictor_8x8 = vpx_tm_predictor_8x8_sse2;
+  vpx_v_predictor_16x16 = vpx_v_predictor_16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_v_predictor_16x16 = vpx_v_predictor_16x16_sse2;
+  vpx_v_predictor_32x32 = vpx_v_predictor_32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_v_predictor_32x32 = vpx_v_predictor_32x32_sse2;
+  vpx_v_predictor_4x4 = vpx_v_predictor_4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_v_predictor_4x4 = vpx_v_predictor_4x4_sse2;
+  vpx_v_predictor_8x8 = vpx_v_predictor_8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_v_predictor_8x8 = vpx_v_predictor_8x8_sse2;
+  vpx_variance16x16 = vpx_variance16x16_c;
+  if (flags & HAS_SSE2)
+    vpx_variance16x16 = vpx_variance16x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance16x16 = vpx_variance16x16_avx2;
+  vpx_variance16x32 = vpx_variance16x32_c;
+  if (flags & HAS_SSE2)
+    vpx_variance16x32 = vpx_variance16x32_sse2;
+  vpx_variance16x8 = vpx_variance16x8_c;
+  if (flags & HAS_SSE2)
+    vpx_variance16x8 = vpx_variance16x8_sse2;
+  vpx_variance32x16 = vpx_variance32x16_c;
+  if (flags & HAS_SSE2)
+    vpx_variance32x16 = vpx_variance32x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance32x16 = vpx_variance32x16_avx2;
+  vpx_variance32x32 = vpx_variance32x32_c;
+  if (flags & HAS_SSE2)
+    vpx_variance32x32 = vpx_variance32x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance32x32 = vpx_variance32x32_avx2;
+  vpx_variance32x64 = vpx_variance32x64_c;
+  if (flags & HAS_SSE2)
+    vpx_variance32x64 = vpx_variance32x64_sse2;
+  vpx_variance4x4 = vpx_variance4x4_c;
+  if (flags & HAS_SSE2)
+    vpx_variance4x4 = vpx_variance4x4_sse2;
+  vpx_variance4x8 = vpx_variance4x8_c;
+  if (flags & HAS_SSE2)
+    vpx_variance4x8 = vpx_variance4x8_sse2;
+  vpx_variance64x32 = vpx_variance64x32_c;
+  if (flags & HAS_SSE2)
+    vpx_variance64x32 = vpx_variance64x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance64x32 = vpx_variance64x32_avx2;
+  vpx_variance64x64 = vpx_variance64x64_c;
+  if (flags & HAS_SSE2)
+    vpx_variance64x64 = vpx_variance64x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance64x64 = vpx_variance64x64_avx2;
+  vpx_variance8x16 = vpx_variance8x16_c;
+  if (flags & HAS_SSE2)
+    vpx_variance8x16 = vpx_variance8x16_sse2;
+  vpx_variance8x4 = vpx_variance8x4_c;
+  if (flags & HAS_SSE2)
+    vpx_variance8x4 = vpx_variance8x4_sse2;
+  vpx_variance8x8 = vpx_variance8x8_c;
+  if (flags & HAS_SSE2)
+    vpx_variance8x8 = vpx_variance8x8_sse2;
+  vpx_vector_var = vpx_vector_var_c;
+  if (flags & HAS_SSE2)
+    vpx_vector_var = vpx_vector_var_sse2;
 }
 #endif
 

third_party/libvpx/source/config/win/ia32/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/win/ia32/vpx_scale_rtcd.h b/third_party/libvpx/source/config/win/ia32/vpx_scale_rtcd.h
index ada0f6d..0ba352cb 100644
--- a/third_party/libvpx/source/config/win/ia32/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/win/ia32/vpx_scale_rtcd.h
@@ -13,55 +13,81 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

third_party/libvpx/source/config/win/x64/vp8_rtcd.h

diff --git a/third_party/libvpx/source/config/win/x64/vp8_rtcd.h b/third_party/libvpx/source/config/win/x64/vp8_rtcd.h
index 8dcc9eb..baafe8be 100644
--- a/third_party/libvpx/source/config/win/x64/vp8_rtcd.h
+++ b/third_party/libvpx/source/config/win/x64/vp8_rtcd.h
@@ -26,230 +26,647 @@
 extern "C" {
 #endif
 
-void vp8_bilinear_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict16x16_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict16x16)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict16x16_c(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+void vp8_bilinear_predict16x16_sse2(unsigned char* src,
+                                    int src_pitch,
+                                    int xofst,
+                                    int yofst,
+                                    unsigned char* dst,
+                                    int dst_pitch);
+void vp8_bilinear_predict16x16_ssse3(unsigned char* src,
+                                     int src_pitch,
+                                     int xofst,
+                                     int yofst,
+                                     unsigned char* dst,
+                                     int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict16x16)(unsigned char* src,
+                                              int src_pitch,
+                                              int xofst,
+                                              int yofst,
+                                              unsigned char* dst,
+                                              int dst_pitch);
 
-void vp8_bilinear_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict4x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict4x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict4x4_mmx(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
 #define vp8_bilinear_predict4x4 vp8_bilinear_predict4x4_mmx
 
-void vp8_bilinear_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x4_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x4_mmx(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
 #define vp8_bilinear_predict8x4 vp8_bilinear_predict8x4_mmx
 
-void vp8_bilinear_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_bilinear_predict8x8_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_bilinear_predict8x8)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_bilinear_predict8x8_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_bilinear_predict8x8_sse2(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+void vp8_bilinear_predict8x8_ssse3(unsigned char* src,
+                                   int src_pitch,
+                                   int xofst,
+                                   int yofst,
+                                   unsigned char* dst,
+                                   int dst_pitch);
+RTCD_EXTERN void (*vp8_bilinear_predict8x8)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_blend_b_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_b_c(unsigned char* y,
+                   unsigned char* u,
+                   unsigned char* v,
+                   int y1,
+                   int u1,
+                   int v1,
+                   int alpha,
+                   int stride);
 #define vp8_blend_b vp8_blend_b_c
 
-void vp8_blend_mb_inner_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_inner_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_inner vp8_blend_mb_inner_c
 
-void vp8_blend_mb_outer_c(unsigned char *y, unsigned char *u, unsigned char *v, int y1, int u1, int v1, int alpha, int stride);
+void vp8_blend_mb_outer_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int y1,
+                          int u1,
+                          int v1,
+                          int alpha,
+                          int stride);
 #define vp8_blend_mb_outer vp8_blend_mb_outer_c
 
-int vp8_block_error_c(short *coeff, short *dqcoeff);
-int vp8_block_error_sse2(short *coeff, short *dqcoeff);
+int vp8_block_error_c(short* coeff, short* dqcoeff);
+int vp8_block_error_sse2(short* coeff, short* dqcoeff);
 #define vp8_block_error vp8_block_error_sse2
 
-void vp8_copy32xn_c(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-void vp8_copy32xn_sse2(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-void vp8_copy32xn_sse3(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
-RTCD_EXTERN void (*vp8_copy32xn)(const unsigned char *src_ptr, int source_stride, unsigned char *dst_ptr, int dst_stride, int n);
+void vp8_copy32xn_c(const unsigned char* src_ptr,
+                    int source_stride,
+                    unsigned char* dst_ptr,
+                    int dst_stride,
+                    int n);
+void vp8_copy32xn_sse2(const unsigned char* src_ptr,
+                       int source_stride,
+                       unsigned char* dst_ptr,
+                       int dst_stride,
+                       int n);
+void vp8_copy32xn_sse3(const unsigned char* src_ptr,
+                       int source_stride,
+                       unsigned char* dst_ptr,
+                       int dst_stride,
+                       int n);
+RTCD_EXTERN void (*vp8_copy32xn)(const unsigned char* src_ptr,
+                                 int source_stride,
+                                 unsigned char* dst_ptr,
+                                 int dst_stride,
+                                 int n);
 
-void vp8_copy_mem16x16_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem16x16_sse2(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem16x16_c(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
+void vp8_copy_mem16x16_sse2(unsigned char* src,
+                            int src_pitch,
+                            unsigned char* dst,
+                            int dst_pitch);
 #define vp8_copy_mem16x16 vp8_copy_mem16x16_sse2
 
-void vp8_copy_mem8x4_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x4_mmx(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x4_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x4_mmx(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
 #define vp8_copy_mem8x4 vp8_copy_mem8x4_mmx
 
-void vp8_copy_mem8x8_c(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
-void vp8_copy_mem8x8_mmx(unsigned char *src, int src_pitch, unsigned char *dst, int dst_pitch);
+void vp8_copy_mem8x8_c(unsigned char* src,
+                       int src_pitch,
+                       unsigned char* dst,
+                       int dst_pitch);
+void vp8_copy_mem8x8_mmx(unsigned char* src,
+                         int src_pitch,
+                         unsigned char* dst,
+                         int dst_pitch);
 #define vp8_copy_mem8x8 vp8_copy_mem8x8_mmx
 
-void vp8_dc_only_idct_add_c(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
-void vp8_dc_only_idct_add_mmx(short input, unsigned char *pred, int pred_stride, unsigned char *dst, int dst_stride);
+void vp8_dc_only_idct_add_c(short input,
+                            unsigned char* pred,
+                            int pred_stride,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_dc_only_idct_add_mmx(short input,
+                              unsigned char* pred,
+                              int pred_stride,
+                              unsigned char* dst,
+                              int dst_stride);
 #define vp8_dc_only_idct_add vp8_dc_only_idct_add_mmx
 
-int vp8_denoiser_filter_c(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_sse2(unsigned char *mc_running_avg_y, int mc_avg_y_stride, unsigned char *running_avg_y, int avg_y_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_c(unsigned char* mc_running_avg_y,
+                          int mc_avg_y_stride,
+                          unsigned char* running_avg_y,
+                          int avg_y_stride,
+                          unsigned char* sig,
+                          int sig_stride,
+                          unsigned int motion_magnitude,
+                          int increase_denoising);
+int vp8_denoiser_filter_sse2(unsigned char* mc_running_avg_y,
+                             int mc_avg_y_stride,
+                             unsigned char* running_avg_y,
+                             int avg_y_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
 #define vp8_denoiser_filter vp8_denoiser_filter_sse2
 
-int vp8_denoiser_filter_uv_c(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
-int vp8_denoiser_filter_uv_sse2(unsigned char *mc_running_avg, int mc_avg_stride, unsigned char *running_avg, int avg_stride, unsigned char *sig, int sig_stride, unsigned int motion_magnitude, int increase_denoising);
+int vp8_denoiser_filter_uv_c(unsigned char* mc_running_avg,
+                             int mc_avg_stride,
+                             unsigned char* running_avg,
+                             int avg_stride,
+                             unsigned char* sig,
+                             int sig_stride,
+                             unsigned int motion_magnitude,
+                             int increase_denoising);
+int vp8_denoiser_filter_uv_sse2(unsigned char* mc_running_avg,
+                                int mc_avg_stride,
+                                unsigned char* running_avg,
+                                int avg_stride,
+                                unsigned char* sig,
+                                int sig_stride,
+                                unsigned int motion_magnitude,
+                                int increase_denoising);
 #define vp8_denoiser_filter_uv vp8_denoiser_filter_uv_sse2
 
-void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *output, int stride);
-void vp8_dequant_idct_add_mmx(short *input, short *dq, unsigned char *output, int stride);
+void vp8_dequant_idct_add_c(short* input,
+                            short* dq,
+                            unsigned char* output,
+                            int stride);
+void vp8_dequant_idct_add_mmx(short* input,
+                              short* dq,
+                              unsigned char* output,
+                              int stride);
 #define vp8_dequant_idct_add vp8_dequant_idct_add_mmx
 
-void vp8_dequant_idct_add_uv_block_c(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
-void vp8_dequant_idct_add_uv_block_sse2(short *q, short *dq, unsigned char *dst_u, unsigned char *dst_v, int stride, char *eobs);
+void vp8_dequant_idct_add_uv_block_c(short* q,
+                                     short* dq,
+                                     unsigned char* dst_u,
+                                     unsigned char* dst_v,
+                                     int stride,
+                                     char* eobs);
+void vp8_dequant_idct_add_uv_block_sse2(short* q,
+                                        short* dq,
+                                        unsigned char* dst_u,
+                                        unsigned char* dst_v,
+                                        int stride,
+                                        char* eobs);
 #define vp8_dequant_idct_add_uv_block vp8_dequant_idct_add_uv_block_sse2
 
-void vp8_dequant_idct_add_y_block_c(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
-void vp8_dequant_idct_add_y_block_sse2(short *q, short *dq, unsigned char *dst, int stride, char *eobs);
+void vp8_dequant_idct_add_y_block_c(short* q,
+                                    short* dq,
+                                    unsigned char* dst,
+                                    int stride,
+                                    char* eobs);
+void vp8_dequant_idct_add_y_block_sse2(short* q,
+                                       short* dq,
+                                       unsigned char* dst,
+                                       int stride,
+                                       char* eobs);
 #define vp8_dequant_idct_add_y_block vp8_dequant_idct_add_y_block_sse2
 
-void vp8_dequantize_b_c(struct blockd*, short *dqc);
-void vp8_dequantize_b_mmx(struct blockd*, short *dqc);
+void vp8_dequantize_b_c(struct blockd*, short* dqc);
+void vp8_dequantize_b_mmx(struct blockd*, short* dqc);
 #define vp8_dequantize_b vp8_dequantize_b_mmx
 
-int vp8_diamond_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_diamond_search_sadx4(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, union int_mv *best_mv, int search_param, int sad_per_bit, int *num00, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_diamond_search_sad_c(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
+int vp8_diamond_search_sadx4(struct macroblock* x,
+                             struct block* b,
+                             struct blockd* d,
+                             union int_mv* ref_mv,
+                             union int_mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             struct variance_vtable* fn_ptr,
+                             int* mvcost[2],
+                             union int_mv* center_mv);
 #define vp8_diamond_search_sad vp8_diamond_search_sadx4
 
-void vp8_fast_quantize_b_c(struct block *, struct blockd *);
-void vp8_fast_quantize_b_sse2(struct block *, struct blockd *);
-void vp8_fast_quantize_b_ssse3(struct block *, struct blockd *);
-RTCD_EXTERN void (*vp8_fast_quantize_b)(struct block *, struct blockd *);
+void vp8_fast_quantize_b_c(struct block*, struct blockd*);
+void vp8_fast_quantize_b_sse2(struct block*, struct blockd*);
+void vp8_fast_quantize_b_ssse3(struct block*, struct blockd*);
+RTCD_EXTERN void (*vp8_fast_quantize_b)(struct block*, struct blockd*);
 
-void vp8_filter_by_weight16x16_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-void vp8_filter_by_weight16x16_sse2(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight16x16_c(unsigned char* src,
+                                 int src_stride,
+                                 unsigned char* dst,
+                                 int dst_stride,
+                                 int src_weight);
+void vp8_filter_by_weight16x16_sse2(unsigned char* src,
+                                    int src_stride,
+                                    unsigned char* dst,
+                                    int dst_stride,
+                                    int src_weight);
 #define vp8_filter_by_weight16x16 vp8_filter_by_weight16x16_sse2
 
-void vp8_filter_by_weight4x4_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight4x4_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
 #define vp8_filter_by_weight4x4 vp8_filter_by_weight4x4_c
 
-void vp8_filter_by_weight8x8_c(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
-void vp8_filter_by_weight8x8_sse2(unsigned char *src, int src_stride, unsigned char *dst, int dst_stride, int src_weight);
+void vp8_filter_by_weight8x8_c(unsigned char* src,
+                               int src_stride,
+                               unsigned char* dst,
+                               int dst_stride,
+                               int src_weight);
+void vp8_filter_by_weight8x8_sse2(unsigned char* src,
+                                  int src_stride,
+                                  unsigned char* dst,
+                                  int dst_stride,
+                                  int src_weight);
 #define vp8_filter_by_weight8x8 vp8_filter_by_weight8x8_sse2
 
-int vp8_full_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_full_search_sadx3(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_full_search_sadx8(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-RTCD_EXTERN int (*vp8_full_search_sad)(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_full_search_sad_c(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+int vp8_full_search_sadx3(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+int vp8_full_search_sadx8(struct macroblock* x,
+                          struct block* b,
+                          struct blockd* d,
+                          union int_mv* ref_mv,
+                          int sad_per_bit,
+                          int distance,
+                          struct variance_vtable* fn_ptr,
+                          int* mvcost[2],
+                          union int_mv* center_mv);
+RTCD_EXTERN int (*vp8_full_search_sad)(struct macroblock* x,
+                                       struct block* b,
+                                       struct blockd* d,
+                                       union int_mv* ref_mv,
+                                       int sad_per_bit,
+                                       int distance,
+                                       struct variance_vtable* fn_ptr,
+                                       int* mvcost[2],
+                                       union int_mv* center_mv);
 
-void vp8_loop_filter_bh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bh_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bh_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bh_sse2(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
 #define vp8_loop_filter_bh vp8_loop_filter_bh_sse2
 
-void vp8_loop_filter_bv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_bv_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_bv_c(unsigned char* y,
+                          unsigned char* u,
+                          unsigned char* v,
+                          int ystride,
+                          int uv_stride,
+                          struct loop_filter_info* lfi);
+void vp8_loop_filter_bv_sse2(unsigned char* y,
+                             unsigned char* u,
+                             unsigned char* v,
+                             int ystride,
+                             int uv_stride,
+                             struct loop_filter_info* lfi);
 #define vp8_loop_filter_bv vp8_loop_filter_bv_sse2
 
-void vp8_loop_filter_mbh_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbh_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbh_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbh_sse2(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbh vp8_loop_filter_mbh_sse2
 
-void vp8_loop_filter_mbv_c(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
-void vp8_loop_filter_mbv_sse2(unsigned char *y, unsigned char *u, unsigned char *v, int ystride, int uv_stride, struct loop_filter_info *lfi);
+void vp8_loop_filter_mbv_c(unsigned char* y,
+                           unsigned char* u,
+                           unsigned char* v,
+                           int ystride,
+                           int uv_stride,
+                           struct loop_filter_info* lfi);
+void vp8_loop_filter_mbv_sse2(unsigned char* y,
+                              unsigned char* u,
+                              unsigned char* v,
+                              int ystride,
+                              int uv_stride,
+                              struct loop_filter_info* lfi);
 #define vp8_loop_filter_mbv vp8_loop_filter_mbv_sse2
 
-void vp8_loop_filter_bhs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bhs_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bhs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bhs_sse2(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_bh vp8_loop_filter_bhs_sse2
 
-void vp8_loop_filter_bvs_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_bvs_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_bvs_c(unsigned char* y,
+                           int ystride,
+                           const unsigned char* blimit);
+void vp8_loop_filter_bvs_sse2(unsigned char* y,
+                              int ystride,
+                              const unsigned char* blimit);
 #define vp8_loop_filter_simple_bv vp8_loop_filter_bvs_sse2
 
-void vp8_loop_filter_simple_horizontal_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_simple_horizontal_edge_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_horizontal_edge_c(unsigned char* y,
+                                              int ystride,
+                                              const unsigned char* blimit);
+void vp8_loop_filter_simple_horizontal_edge_sse2(unsigned char* y,
+                                                 int ystride,
+                                                 const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbh vp8_loop_filter_simple_horizontal_edge_sse2
 
-void vp8_loop_filter_simple_vertical_edge_c(unsigned char *y, int ystride, const unsigned char *blimit);
-void vp8_loop_filter_simple_vertical_edge_sse2(unsigned char *y, int ystride, const unsigned char *blimit);
+void vp8_loop_filter_simple_vertical_edge_c(unsigned char* y,
+                                            int ystride,
+                                            const unsigned char* blimit);
+void vp8_loop_filter_simple_vertical_edge_sse2(unsigned char* y,
+                                               int ystride,
+                                               const unsigned char* blimit);
 #define vp8_loop_filter_simple_mbv vp8_loop_filter_simple_vertical_edge_sse2
 
-int vp8_mbblock_error_c(struct macroblock *mb, int dc);
-int vp8_mbblock_error_sse2(struct macroblock *mb, int dc);
+int vp8_mbblock_error_c(struct macroblock* mb, int dc);
+int vp8_mbblock_error_sse2(struct macroblock* mb, int dc);
 #define vp8_mbblock_error vp8_mbblock_error_sse2
 
-int vp8_mbuverror_c(struct macroblock *mb);
-int vp8_mbuverror_sse2(struct macroblock *mb);
+int vp8_mbuverror_c(struct macroblock* mb);
+int vp8_mbuverror_sse2(struct macroblock* mb);
 #define vp8_mbuverror vp8_mbuverror_sse2
 
-int vp8_refining_search_sad_c(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
-int vp8_refining_search_sadx4(struct macroblock *x, struct block *b, struct blockd *d, union int_mv *ref_mv, int sad_per_bit, int distance, struct variance_vtable *fn_ptr, int *mvcost[2], union int_mv *center_mv);
+int vp8_refining_search_sad_c(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
+int vp8_refining_search_sadx4(struct macroblock* x,
+                              struct block* b,
+                              struct blockd* d,
+                              union int_mv* ref_mv,
+                              int sad_per_bit,
+                              int distance,
+                              struct variance_vtable* fn_ptr,
+                              int* mvcost[2],
+                              union int_mv* center_mv);
 #define vp8_refining_search_sad vp8_refining_search_sadx4
 
-void vp8_regular_quantize_b_c(struct block *, struct blockd *);
-void vp8_regular_quantize_b_sse2(struct block *, struct blockd *);
-void vp8_regular_quantize_b_sse4_1(struct block *, struct blockd *);
-RTCD_EXTERN void (*vp8_regular_quantize_b)(struct block *, struct blockd *);
+void vp8_regular_quantize_b_c(struct block*, struct blockd*);
+void vp8_regular_quantize_b_sse2(struct block*, struct blockd*);
+void vp8_regular_quantize_b_sse4_1(struct block*, struct blockd*);
+RTCD_EXTERN void (*vp8_regular_quantize_b)(struct block*, struct blockd*);
 
-void vp8_short_fdct4x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct4x4_sse2(short *input, short *output, int pitch);
+void vp8_short_fdct4x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct4x4_sse2(short* input, short* output, int pitch);
 #define vp8_short_fdct4x4 vp8_short_fdct4x4_sse2
 
-void vp8_short_fdct8x4_c(short *input, short *output, int pitch);
-void vp8_short_fdct8x4_sse2(short *input, short *output, int pitch);
+void vp8_short_fdct8x4_c(short* input, short* output, int pitch);
+void vp8_short_fdct8x4_sse2(short* input, short* output, int pitch);
 #define vp8_short_fdct8x4 vp8_short_fdct8x4_sse2
 
-void vp8_short_idct4x4llm_c(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
-void vp8_short_idct4x4llm_mmx(short *input, unsigned char *pred, int pitch, unsigned char *dst, int dst_stride);
+void vp8_short_idct4x4llm_c(short* input,
+                            unsigned char* pred,
+                            int pitch,
+                            unsigned char* dst,
+                            int dst_stride);
+void vp8_short_idct4x4llm_mmx(short* input,
+                              unsigned char* pred,
+                              int pitch,
+                              unsigned char* dst,
+                              int dst_stride);
 #define vp8_short_idct4x4llm vp8_short_idct4x4llm_mmx
 
-void vp8_short_inv_walsh4x4_c(short *input, short *output);
-void vp8_short_inv_walsh4x4_sse2(short *input, short *output);
+void vp8_short_inv_walsh4x4_c(short* input, short* output);
+void vp8_short_inv_walsh4x4_sse2(short* input, short* output);
 #define vp8_short_inv_walsh4x4 vp8_short_inv_walsh4x4_sse2
 
-void vp8_short_inv_walsh4x4_1_c(short *input, short *output);
+void vp8_short_inv_walsh4x4_1_c(short* input, short* output);
 #define vp8_short_inv_walsh4x4_1 vp8_short_inv_walsh4x4_1_c
 
-void vp8_short_walsh4x4_c(short *input, short *output, int pitch);
-void vp8_short_walsh4x4_sse2(short *input, short *output, int pitch);
+void vp8_short_walsh4x4_c(short* input, short* output, int pitch);
+void vp8_short_walsh4x4_sse2(short* input, short* output, int pitch);
 #define vp8_short_walsh4x4 vp8_short_walsh4x4_sse2
 
-void vp8_sixtap_predict16x16_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict16x16_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict16x16)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict16x16_c(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict16x16_sse2(unsigned char* src,
+                                  int src_pitch,
+                                  int xofst,
+                                  int yofst,
+                                  unsigned char* dst,
+                                  int dst_pitch);
+void vp8_sixtap_predict16x16_ssse3(unsigned char* src,
+                                   int src_pitch,
+                                   int xofst,
+                                   int yofst,
+                                   unsigned char* dst,
+                                   int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict16x16)(unsigned char* src,
+                                            int src_pitch,
+                                            int xofst,
+                                            int yofst,
+                                            unsigned char* dst,
+                                            int dst_pitch);
 
-void vp8_sixtap_predict4x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_mmx(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict4x4_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict4x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict4x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict4x4_mmx(unsigned char* src,
+                               int src_pitch,
+                               int xofst,
+                               int yofst,
+                               unsigned char* dst,
+                               int dst_pitch);
+void vp8_sixtap_predict4x4_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict4x4)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
-void vp8_sixtap_predict8x4_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x4_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict8x4)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x4_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x4_sse2(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+void vp8_sixtap_predict8x4_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict8x4)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
-void vp8_sixtap_predict8x8_c(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_sse2(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-void vp8_sixtap_predict8x8_ssse3(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
-RTCD_EXTERN void (*vp8_sixtap_predict8x8)(unsigned char *src, int src_pitch, int xofst, int yofst, unsigned char *dst, int dst_pitch);
+void vp8_sixtap_predict8x8_c(unsigned char* src,
+                             int src_pitch,
+                             int xofst,
+                             int yofst,
+                             unsigned char* dst,
+                             int dst_pitch);
+void vp8_sixtap_predict8x8_sse2(unsigned char* src,
+                                int src_pitch,
+                                int xofst,
+                                int yofst,
+                                unsigned char* dst,
+                                int dst_pitch);
+void vp8_sixtap_predict8x8_ssse3(unsigned char* src,
+                                 int src_pitch,
+                                 int xofst,
+                                 int yofst,
+                                 unsigned char* dst,
+                                 int dst_pitch);
+RTCD_EXTERN void (*vp8_sixtap_predict8x8)(unsigned char* src,
+                                          int src_pitch,
+                                          int xofst,
+                                          int yofst,
+                                          unsigned char* dst,
+                                          int dst_pitch);
 
 void vp8_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_sse2;
-    if (flags & HAS_SSSE3) vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_ssse3;
-    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_sse2;
-    if (flags & HAS_SSSE3) vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_ssse3;
-    vp8_copy32xn = vp8_copy32xn_sse2;
-    if (flags & HAS_SSE3) vp8_copy32xn = vp8_copy32xn_sse3;
-    vp8_fast_quantize_b = vp8_fast_quantize_b_sse2;
-    if (flags & HAS_SSSE3) vp8_fast_quantize_b = vp8_fast_quantize_b_ssse3;
-    vp8_full_search_sad = vp8_full_search_sad_c;
-    if (flags & HAS_SSE3) vp8_full_search_sad = vp8_full_search_sadx3;
-    if (flags & HAS_SSE4_1) vp8_full_search_sad = vp8_full_search_sadx8;
-    vp8_regular_quantize_b = vp8_regular_quantize_b_sse2;
-    if (flags & HAS_SSE4_1) vp8_regular_quantize_b = vp8_regular_quantize_b_sse4_1;
-    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_ssse3;
-    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_mmx;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_ssse3;
-    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_ssse3;
-    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_sse2;
-    if (flags & HAS_SSSE3) vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_ssse3;
+  vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_bilinear_predict16x16 = vp8_bilinear_predict16x16_ssse3;
+  vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_bilinear_predict8x8 = vp8_bilinear_predict8x8_ssse3;
+  vp8_copy32xn = vp8_copy32xn_sse2;
+  if (flags & HAS_SSE3)
+    vp8_copy32xn = vp8_copy32xn_sse3;
+  vp8_fast_quantize_b = vp8_fast_quantize_b_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_fast_quantize_b = vp8_fast_quantize_b_ssse3;
+  vp8_full_search_sad = vp8_full_search_sad_c;
+  if (flags & HAS_SSE3)
+    vp8_full_search_sad = vp8_full_search_sadx3;
+  if (flags & HAS_SSE4_1)
+    vp8_full_search_sad = vp8_full_search_sadx8;
+  vp8_regular_quantize_b = vp8_regular_quantize_b_sse2;
+  if (flags & HAS_SSE4_1)
+    vp8_regular_quantize_b = vp8_regular_quantize_b_sse4_1;
+  vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict16x16 = vp8_sixtap_predict16x16_ssse3;
+  vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_mmx;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict4x4 = vp8_sixtap_predict4x4_ssse3;
+  vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict8x4 = vp8_sixtap_predict8x4_ssse3;
+  vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vp8_sixtap_predict8x8 = vp8_sixtap_predict8x8_ssse3;
 }
 #endif
 

third_party/libvpx/source/config/win/x64/vp9_rtcd.h

diff --git a/third_party/libvpx/source/config/win/x64/vp9_rtcd.h b/third_party/libvpx/source/config/win/x64/vp9_rtcd.h
index 415d6be..b985873 100644
--- a/third_party/libvpx/source/config/win/x64/vp9_rtcd.h
+++ b/third_party/libvpx/source/config/win/x64/vp9_rtcd.h
@@ -11,10 +11,10 @@
  * VP9
  */
 
-#include "vpx/vpx_integer.h"
 #include "vp9/common/vp9_common.h"
 #include "vp9/common/vp9_enums.h"
 #include "vp9/common/vp9_filter.h"
+#include "vpx/vpx_integer.h"
 
 struct macroblockd;
 
@@ -30,147 +30,474 @@
 extern "C" {
 #endif
 
-int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-int64_t vp9_block_error_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-int64_t vp9_block_error_avx2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
-RTCD_EXTERN int64_t (*vp9_block_error)(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz);
+int64_t vp9_block_error_c(const tran_low_t* coeff,
+                          const tran_low_t* dqcoeff,
+                          intptr_t block_size,
+                          int64_t* ssz);
+int64_t vp9_block_error_sse2(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             intptr_t block_size,
+                             int64_t* ssz);
+int64_t vp9_block_error_avx2(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             intptr_t block_size,
+                             int64_t* ssz);
+RTCD_EXTERN int64_t (*vp9_block_error)(const tran_low_t* coeff,
+                                       const tran_low_t* dqcoeff,
+                                       intptr_t block_size,
+                                       int64_t* ssz);
 
-int64_t vp9_block_error_fp_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
-int64_t vp9_block_error_fp_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, int block_size);
+int64_t vp9_block_error_fp_c(const tran_low_t* coeff,
+                             const tran_low_t* dqcoeff,
+                             int block_size);
+int64_t vp9_block_error_fp_sse2(const tran_low_t* coeff,
+                                const tran_low_t* dqcoeff,
+                                int block_size);
 #define vp9_block_error_fp vp9_block_error_fp_sse2
 
-int vp9_denoiser_filter_c(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
-int vp9_denoiser_filter_sse2(const uint8_t *sig, int sig_stride, const uint8_t *mc_avg, int mc_avg_stride, uint8_t *avg, int avg_stride, int increase_denoising, BLOCK_SIZE bs, int motion_magnitude);
+int vp9_denoiser_filter_c(const uint8_t* sig,
+                          int sig_stride,
+                          const uint8_t* mc_avg,
+                          int mc_avg_stride,
+                          uint8_t* avg,
+                          int avg_stride,
+                          int increase_denoising,
+                          BLOCK_SIZE bs,
+                          int motion_magnitude);
+int vp9_denoiser_filter_sse2(const uint8_t* sig,
+                             int sig_stride,
+                             const uint8_t* mc_avg,
+                             int mc_avg_stride,
+                             uint8_t* avg,
+                             int avg_stride,
+                             int increase_denoising,
+                             BLOCK_SIZE bs,
+                             int motion_magnitude);
 #define vp9_denoiser_filter vp9_denoiser_filter_sse2
 
-int vp9_diamond_search_sad_c(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
-int vp9_diamond_search_sad_avx(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
-RTCD_EXTERN int (*vp9_diamond_search_sad)(const struct macroblock *x, const struct search_site_config *cfg,  struct mv *ref_mv, struct mv *best_mv, int search_param, int sad_per_bit, int *num00, const struct vp9_variance_vtable *fn_ptr, const struct mv *center_mv);
+int vp9_diamond_search_sad_c(const struct macroblock* x,
+                             const struct search_site_config* cfg,
+                             struct mv* ref_mv,
+                             struct mv* best_mv,
+                             int search_param,
+                             int sad_per_bit,
+                             int* num00,
+                             const struct vp9_variance_vtable* fn_ptr,
+                             const struct mv* center_mv);
+int vp9_diamond_search_sad_avx(const struct macroblock* x,
+                               const struct search_site_config* cfg,
+                               struct mv* ref_mv,
+                               struct mv* best_mv,
+                               int search_param,
+                               int sad_per_bit,
+                               int* num00,
+                               const struct vp9_variance_vtable* fn_ptr,
+                               const struct mv* center_mv);
+RTCD_EXTERN int (*vp9_diamond_search_sad)(
+    const struct macroblock* x,
+    const struct search_site_config* cfg,
+    struct mv* ref_mv,
+    struct mv* best_mv,
+    int search_param,
+    int sad_per_bit,
+    int* num00,
+    const struct vp9_variance_vtable* fn_ptr,
+    const struct mv* center_mv);
 
-void vp9_fdct8x8_quant_c(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_fdct8x8_quant_ssse3(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_fdct8x8_quant)(const int16_t *input, int stride, tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_fdct8x8_quant_c(const int16_t* input,
+                         int stride,
+                         tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+void vp9_fdct8x8_quant_ssse3(const int16_t* input,
+                             int stride,
+                             tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+RTCD_EXTERN void (*vp9_fdct8x8_quant)(const int16_t* input,
+                                      int stride,
+                                      tran_low_t* coeff_ptr,
+                                      intptr_t n_coeffs,
+                                      int skip_block,
+                                      const int16_t* round_ptr,
+                                      const int16_t* quant_ptr,
+                                      tran_low_t* qcoeff_ptr,
+                                      tran_low_t* dqcoeff_ptr,
+                                      const int16_t* dequant_ptr,
+                                      uint16_t* eob_ptr,
+                                      const int16_t* scan,
+                                      const int16_t* iscan);
 
-void vp9_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht16x16_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht16x16_c(const int16_t* input,
+                    tran_low_t* output,
+                    int stride,
+                    int tx_type);
+void vp9_fht16x16_sse2(const int16_t* input,
+                       tran_low_t* output,
+                       int stride,
+                       int tx_type);
 #define vp9_fht16x16 vp9_fht16x16_sse2
 
-void vp9_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht4x4_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht4x4_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
+void vp9_fht4x4_sse2(const int16_t* input,
+                     tran_low_t* output,
+                     int stride,
+                     int tx_type);
 #define vp9_fht4x4 vp9_fht4x4_sse2
 
-void vp9_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
-void vp9_fht8x8_sse2(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_fht8x8_c(const int16_t* input,
+                  tran_low_t* output,
+                  int stride,
+                  int tx_type);
+void vp9_fht8x8_sse2(const int16_t* input,
+                     tran_low_t* output,
+                     int stride,
+                     int tx_type);
 #define vp9_fht8x8 vp9_fht8x8_sse2
 
-void vp9_filter_by_weight16x16_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-void vp9_filter_by_weight16x16_sse2(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight16x16_c(const uint8_t* src,
+                                 int src_stride,
+                                 uint8_t* dst,
+                                 int dst_stride,
+                                 int src_weight);
+void vp9_filter_by_weight16x16_sse2(const uint8_t* src,
+                                    int src_stride,
+                                    uint8_t* dst,
+                                    int dst_stride,
+                                    int src_weight);
 #define vp9_filter_by_weight16x16 vp9_filter_by_weight16x16_sse2
 
-void vp9_filter_by_weight8x8_c(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
-void vp9_filter_by_weight8x8_sse2(const uint8_t *src, int src_stride, uint8_t *dst, int dst_stride, int src_weight);
+void vp9_filter_by_weight8x8_c(const uint8_t* src,
+                               int src_stride,
+                               uint8_t* dst,
+                               int dst_stride,
+                               int src_weight);
+void vp9_filter_by_weight8x8_sse2(const uint8_t* src,
+                                  int src_stride,
+                                  uint8_t* dst,
+                                  int dst_stride,
+                                  int src_weight);
 #define vp9_filter_by_weight8x8 vp9_filter_by_weight8x8_sse2
 
-void vp9_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vp9_fwht4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vp9_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vp9_fwht4x4_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_fwht4x4 vp9_fwht4x4_sse2
 
-int64_t vp9_highbd_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
-int64_t vp9_highbd_block_error_sse2(const tran_low_t *coeff, const tran_low_t *dqcoeff, intptr_t block_size, int64_t *ssz, int bd);
+int64_t vp9_highbd_block_error_c(const tran_low_t* coeff,
+                                 const tran_low_t* dqcoeff,
+                                 intptr_t block_size,
+                                 int64_t* ssz,
+                                 int bd);
+int64_t vp9_highbd_block_error_sse2(const tran_low_t* coeff,
+                                    const tran_low_t* dqcoeff,
+                                    intptr_t block_size,
+                                    int64_t* ssz,
+                                    int bd);
 #define vp9_highbd_block_error vp9_highbd_block_error_sse2
 
-void vp9_highbd_fht16x16_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht16x16_c(const int16_t* input,
+                           tran_low_t* output,
+                           int stride,
+                           int tx_type);
 #define vp9_highbd_fht16x16 vp9_highbd_fht16x16_c
 
-void vp9_highbd_fht4x4_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht4x4_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht4x4 vp9_highbd_fht4x4_c
 
-void vp9_highbd_fht8x8_c(const int16_t *input, tran_low_t *output, int stride, int tx_type);
+void vp9_highbd_fht8x8_c(const int16_t* input,
+                         tran_low_t* output,
+                         int stride,
+                         int tx_type);
 #define vp9_highbd_fht8x8 vp9_highbd_fht8x8_c
 
-void vp9_highbd_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride);
+void vp9_highbd_fwht4x4_c(const int16_t* input, tran_low_t* output, int stride);
 #define vp9_highbd_fwht4x4 vp9_highbd_fwht4x4_c
 
-void vp9_highbd_iht16x16_256_add_c(const tran_low_t *input, uint16_t *output, int pitch, int tx_type, int bd);
+void vp9_highbd_iht16x16_256_add_c(const tran_low_t* input,
+                                   uint16_t* output,
+                                   int pitch,
+                                   int tx_type,
+                                   int bd);
 #define vp9_highbd_iht16x16_256_add vp9_highbd_iht16x16_256_add_c
 
-void vp9_highbd_iht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht4x4_16_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht4x4_16_add vp9_highbd_iht4x4_16_add_c
 
-void vp9_highbd_iht8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int tx_type, int bd);
+void vp9_highbd_iht8x8_64_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int tx_type,
+                                int bd);
 #define vp9_highbd_iht8x8_64_add vp9_highbd_iht8x8_64_add_c
 
-void vp9_highbd_mbpost_proc_across_ip_c(uint16_t *src, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_across_ip_c(uint16_t* src,
+                                        int pitch,
+                                        int rows,
+                                        int cols,
+                                        int flimit);
 #define vp9_highbd_mbpost_proc_across_ip vp9_highbd_mbpost_proc_across_ip_c
 
-void vp9_highbd_mbpost_proc_down_c(uint16_t *dst, int pitch, int rows, int cols, int flimit);
+void vp9_highbd_mbpost_proc_down_c(uint16_t* dst,
+                                   int pitch,
+                                   int rows,
+                                   int cols,
+                                   int flimit);
 #define vp9_highbd_mbpost_proc_down vp9_highbd_mbpost_proc_down_c
 
-void vp9_highbd_post_proc_down_and_across_c(const uint16_t *src_ptr, uint16_t *dst_ptr, int src_pixels_per_line, int dst_pixels_per_line, int rows, int cols, int flimit);
-#define vp9_highbd_post_proc_down_and_across vp9_highbd_post_proc_down_and_across_c
+void vp9_highbd_post_proc_down_and_across_c(const uint16_t* src_ptr,
+                                            uint16_t* dst_ptr,
+                                            int src_pixels_per_line,
+                                            int dst_pixels_per_line,
+                                            int rows,
+                                            int cols,
+                                            int flimit);
+#define vp9_highbd_post_proc_down_and_across \
+  vp9_highbd_post_proc_down_and_across_c
 
-void vp9_highbd_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_c(const tran_low_t* coeff_ptr,
+                              intptr_t n_coeffs,
+                              int skip_block,
+                              const int16_t* round_ptr,
+                              const int16_t* quant_ptr,
+                              tran_low_t* qcoeff_ptr,
+                              tran_low_t* dqcoeff_ptr,
+                              const int16_t* dequant_ptr,
+                              uint16_t* eob_ptr,
+                              const int16_t* scan,
+                              const int16_t* iscan);
 #define vp9_highbd_quantize_fp vp9_highbd_quantize_fp_c
 
-void vp9_highbd_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_highbd_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 #define vp9_highbd_quantize_fp_32x32 vp9_highbd_quantize_fp_32x32_c
 
-void vp9_highbd_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_highbd_temporal_filter_apply_c(const uint8_t* frame1,
+                                        unsigned int stride,
+                                        const uint8_t* frame2,
+                                        unsigned int block_width,
+                                        unsigned int block_height,
+                                        int strength,
+                                        int filter_weight,
+                                        uint32_t* accumulator,
+                                        uint16_t* count);
 #define vp9_highbd_temporal_filter_apply vp9_highbd_temporal_filter_apply_c
 
-void vp9_iht16x16_256_add_c(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
-void vp9_iht16x16_256_add_sse2(const tran_low_t *input, uint8_t *output, int pitch, int tx_type);
+void vp9_iht16x16_256_add_c(const tran_low_t* input,
+                            uint8_t* output,
+                            int pitch,
+                            int tx_type);
+void vp9_iht16x16_256_add_sse2(const tran_low_t* input,
+                               uint8_t* output,
+                               int pitch,
+                               int tx_type);
 #define vp9_iht16x16_256_add vp9_iht16x16_256_add_sse2
 
-void vp9_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht4x4_16_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht4x4_16_add_sse2(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
 #define vp9_iht4x4_16_add vp9_iht4x4_16_add_sse2
 
-void vp9_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
-void vp9_iht8x8_64_add_sse2(const tran_low_t *input, uint8_t *dest, int stride, int tx_type);
+void vp9_iht8x8_64_add_c(const tran_low_t* input,
+                         uint8_t* dest,
+                         int stride,
+                         int tx_type);
+void vp9_iht8x8_64_add_sse2(const tran_low_t* input,
+                            uint8_t* dest,
+                            int stride,
+                            int tx_type);
 #define vp9_iht8x8_64_add vp9_iht8x8_64_add_sse2
 
-void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_ssse3(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_quantize_fp)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_c(const tran_low_t* coeff_ptr,
+                       intptr_t n_coeffs,
+                       int skip_block,
+                       const int16_t* round_ptr,
+                       const int16_t* quant_ptr,
+                       tran_low_t* qcoeff_ptr,
+                       tran_low_t* dqcoeff_ptr,
+                       const int16_t* dequant_ptr,
+                       uint16_t* eob_ptr,
+                       const int16_t* scan,
+                       const int16_t* iscan);
+void vp9_quantize_fp_sse2(const tran_low_t* coeff_ptr,
+                          intptr_t n_coeffs,
+                          int skip_block,
+                          const int16_t* round_ptr,
+                          const int16_t* quant_ptr,
+                          tran_low_t* qcoeff_ptr,
+                          tran_low_t* dqcoeff_ptr,
+                          const int16_t* dequant_ptr,
+                          uint16_t* eob_ptr,
+                          const int16_t* scan,
+                          const int16_t* iscan);
+void vp9_quantize_fp_ssse3(const tran_low_t* coeff_ptr,
+                           intptr_t n_coeffs,
+                           int skip_block,
+                           const int16_t* round_ptr,
+                           const int16_t* quant_ptr,
+                           tran_low_t* qcoeff_ptr,
+                           tran_low_t* dqcoeff_ptr,
+                           const int16_t* dequant_ptr,
+                           uint16_t* eob_ptr,
+                           const int16_t* scan,
+                           const int16_t* iscan);
+RTCD_EXTERN void (*vp9_quantize_fp)(const tran_low_t* coeff_ptr,
+                                    intptr_t n_coeffs,
+                                    int skip_block,
+                                    const int16_t* round_ptr,
+                                    const int16_t* quant_ptr,
+                                    tran_low_t* qcoeff_ptr,
+                                    tran_low_t* dqcoeff_ptr,
+                                    const int16_t* dequant_ptr,
+                                    uint16_t* eob_ptr,
+                                    const int16_t* scan,
+                                    const int16_t* iscan);
 
-void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vp9_quantize_fp_32x32_ssse3(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vp9_quantize_fp_32x32)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *round_ptr, const int16_t *quant_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vp9_quantize_fp_32x32_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+void vp9_quantize_fp_32x32_ssse3(const tran_low_t* coeff_ptr,
+                                 intptr_t n_coeffs,
+                                 int skip_block,
+                                 const int16_t* round_ptr,
+                                 const int16_t* quant_ptr,
+                                 tran_low_t* qcoeff_ptr,
+                                 tran_low_t* dqcoeff_ptr,
+                                 const int16_t* dequant_ptr,
+                                 uint16_t* eob_ptr,
+                                 const int16_t* scan,
+                                 const int16_t* iscan);
+RTCD_EXTERN void (*vp9_quantize_fp_32x32)(const tran_low_t* coeff_ptr,
+                                          intptr_t n_coeffs,
+                                          int skip_block,
+                                          const int16_t* round_ptr,
+                                          const int16_t* quant_ptr,
+                                          tran_low_t* qcoeff_ptr,
+                                          tran_low_t* dqcoeff_ptr,
+                                          const int16_t* dequant_ptr,
+                                          uint16_t* eob_ptr,
+                                          const int16_t* scan,
+                                          const int16_t* iscan);
 
-void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
-void vp9_scale_and_extend_frame_ssse3(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
-RTCD_EXTERN void (*vp9_scale_and_extend_frame)(const struct yv12_buffer_config *src, struct yv12_buffer_config *dst, INTERP_FILTER filter_type, int phase_scaler);
+void vp9_scale_and_extend_frame_c(const struct yv12_buffer_config* src,
+                                  struct yv12_buffer_config* dst,
+                                  INTERP_FILTER filter_type,
+                                  int phase_scaler);
+void vp9_scale_and_extend_frame_ssse3(const struct yv12_buffer_config* src,
+                                      struct yv12_buffer_config* dst,
+                                      INTERP_FILTER filter_type,
+                                      int phase_scaler);
+RTCD_EXTERN void (*vp9_scale_and_extend_frame)(
+    const struct yv12_buffer_config* src,
+    struct yv12_buffer_config* dst,
+    INTERP_FILTER filter_type,
+    int phase_scaler);
 
-void vp9_temporal_filter_apply_c(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
-void vp9_temporal_filter_apply_sse4_1(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
-RTCD_EXTERN void (*vp9_temporal_filter_apply)(const uint8_t *frame1, unsigned int stride, const uint8_t *frame2, unsigned int block_width, unsigned int block_height, int strength, int filter_weight, uint32_t *accumulator, uint16_t *count);
+void vp9_temporal_filter_apply_c(const uint8_t* frame1,
+                                 unsigned int stride,
+                                 const uint8_t* frame2,
+                                 unsigned int block_width,
+                                 unsigned int block_height,
+                                 int strength,
+                                 int filter_weight,
+                                 uint32_t* accumulator,
+                                 uint16_t* count);
+void vp9_temporal_filter_apply_sse4_1(const uint8_t* frame1,
+                                      unsigned int stride,
+                                      const uint8_t* frame2,
+                                      unsigned int block_width,
+                                      unsigned int block_height,
+                                      int strength,
+                                      int filter_weight,
+                                      uint32_t* accumulator,
+                                      uint16_t* count);
+RTCD_EXTERN void (*vp9_temporal_filter_apply)(const uint8_t* frame1,
+                                              unsigned int stride,
+                                              const uint8_t* frame2,
+                                              unsigned int block_width,
+                                              unsigned int block_height,
+                                              int strength,
+                                              int filter_weight,
+                                              uint32_t* accumulator,
+                                              uint16_t* count);
 
 void vp9_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vp9_block_error = vp9_block_error_sse2;
-    if (flags & HAS_AVX2) vp9_block_error = vp9_block_error_avx2;
-    vp9_diamond_search_sad = vp9_diamond_search_sad_c;
-    if (flags & HAS_AVX) vp9_diamond_search_sad = vp9_diamond_search_sad_avx;
-    vp9_fdct8x8_quant = vp9_fdct8x8_quant_c;
-    if (flags & HAS_SSSE3) vp9_fdct8x8_quant = vp9_fdct8x8_quant_ssse3;
-    vp9_quantize_fp = vp9_quantize_fp_sse2;
-    if (flags & HAS_SSSE3) vp9_quantize_fp = vp9_quantize_fp_ssse3;
-    vp9_quantize_fp_32x32 = vp9_quantize_fp_32x32_c;
-    if (flags & HAS_SSSE3) vp9_quantize_fp_32x32 = vp9_quantize_fp_32x32_ssse3;
-    vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_c;
-    if (flags & HAS_SSSE3) vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_ssse3;
-    vp9_temporal_filter_apply = vp9_temporal_filter_apply_c;
-    if (flags & HAS_SSE4_1) vp9_temporal_filter_apply = vp9_temporal_filter_apply_sse4_1;
+  vp9_block_error = vp9_block_error_sse2;
+  if (flags & HAS_AVX2)
+    vp9_block_error = vp9_block_error_avx2;
+  vp9_diamond_search_sad = vp9_diamond_search_sad_c;
+  if (flags & HAS_AVX)
+    vp9_diamond_search_sad = vp9_diamond_search_sad_avx;
+  vp9_fdct8x8_quant = vp9_fdct8x8_quant_c;
+  if (flags & HAS_SSSE3)
+    vp9_fdct8x8_quant = vp9_fdct8x8_quant_ssse3;
+  vp9_quantize_fp = vp9_quantize_fp_sse2;
+  if (flags & HAS_SSSE3)
+    vp9_quantize_fp = vp9_quantize_fp_ssse3;
+  vp9_quantize_fp_32x32 = vp9_quantize_fp_32x32_c;
+  if (flags & HAS_SSSE3)
+    vp9_quantize_fp_32x32 = vp9_quantize_fp_32x32_ssse3;
+  vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_c;
+  if (flags & HAS_SSSE3)
+    vp9_scale_and_extend_frame = vp9_scale_and_extend_frame_ssse3;
+  vp9_temporal_filter_apply = vp9_temporal_filter_apply_c;
+  if (flags & HAS_SSE4_1)
+    vp9_temporal_filter_apply = vp9_temporal_filter_apply_sse4_1;
 }
 #endif
 

third_party/libvpx/source/config/win/x64/vpx_config.asm

diff --git a/third_party/libvpx/source/config/win/x64/vpx_config.asm b/third_party/libvpx/source/config/win/x64/vpx_config.asm
index 0cbec22..a2844c7 100644
--- a/third_party/libvpx/source/config/win/x64/vpx_config.asm
+++ b/third_party/libvpx/source/config/win/x64/vpx_config.asm
@@ -18,6 +18,7 @@
 %define HAVE_AVX 1
 %define HAVE_AVX2 1
 %define HAVE_VSX 0
+%define HAVE_MMI 0
 %define HAVE_VPX_PORTS 1
 %define HAVE_PTHREAD_H 0
 %define HAVE_UNISTD_H 0

third_party/libvpx/source/config/win/x64/vpx_config.h

diff --git a/third_party/libvpx/source/config/win/x64/vpx_config.h b/third_party/libvpx/source/config/win/x64/vpx_config.h
index 490454d..bf7263a 100644
--- a/third_party/libvpx/source/config/win/x64/vpx_config.h
+++ b/third_party/libvpx/source/config/win/x64/vpx_config.h
@@ -30,6 +30,7 @@
 #define HAVE_AVX 1
 #define HAVE_AVX2 1
 #define HAVE_VSX 0
+#define HAVE_MMI 0
 #define HAVE_VPX_PORTS 1
 #define HAVE_PTHREAD_H 0
 #define HAVE_UNISTD_H 0

third_party/libvpx/source/config/win/x64/vpx_dsp_rtcd.h

diff --git a/third_party/libvpx/source/config/win/x64/vpx_dsp_rtcd.h b/third_party/libvpx/source/config/win/x64/vpx_dsp_rtcd.h
index 742dbff..05579e2d 100644
--- a/third_party/libvpx/source/config/win/x64/vpx_dsp_rtcd.h
+++ b/third_party/libvpx/source/config/win/x64/vpx_dsp_rtcd.h
@@ -14,2175 +14,7391 @@
 #include "vpx/vpx_integer.h"
 #include "vpx_dsp/vpx_dsp_common.h"
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-unsigned int vpx_avg_4x4_c(const uint8_t *, int p);
-unsigned int vpx_avg_4x4_sse2(const uint8_t *, int p);
+unsigned int vpx_avg_4x4_c(const uint8_t*, int p);
+unsigned int vpx_avg_4x4_sse2(const uint8_t*, int p);
 #define vpx_avg_4x4 vpx_avg_4x4_sse2
 
-unsigned int vpx_avg_8x8_c(const uint8_t *, int p);
-unsigned int vpx_avg_8x8_sse2(const uint8_t *, int p);
+unsigned int vpx_avg_8x8_c(const uint8_t*, int p);
+unsigned int vpx_avg_8x8_sse2(const uint8_t*, int p);
 #define vpx_avg_8x8 vpx_avg_8x8_sse2
 
-void vpx_comp_avg_pred_c(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
-void vpx_comp_avg_pred_sse2(uint8_t *comp_pred, const uint8_t *pred, int width, int height, const uint8_t *ref, int ref_stride);
+void vpx_comp_avg_pred_c(uint8_t* comp_pred,
+                         const uint8_t* pred,
+                         int width,
+                         int height,
+                         const uint8_t* ref,
+                         int ref_stride);
+void vpx_comp_avg_pred_sse2(uint8_t* comp_pred,
+                            const uint8_t* pred,
+                            int width,
+                            int height,
+                            const uint8_t* ref,
+                            int ref_stride);
 #define vpx_comp_avg_pred vpx_comp_avg_pred_sse2
 
-void vpx_convolve8_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_convolve8_sse2(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve8_ssse3(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avx2(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+RTCD_EXTERN void (*vpx_convolve8)(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 
-void vpx_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve8_avg_sse2(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
+void vpx_convolve8_avg_ssse3(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+RTCD_EXTERN void (*vpx_convolve8_avg)(const uint8_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint8_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h);
 
-void vpx_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_horiz_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg_horiz)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_horiz_c(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_avg_horiz_sse2(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
+void vpx_convolve8_avg_horiz_ssse3(const uint8_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint8_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h);
+RTCD_EXTERN void (*vpx_convolve8_avg_horiz)(const uint8_t* src,
+                                            ptrdiff_t src_stride,
+                                            uint8_t* dst,
+                                            ptrdiff_t dst_stride,
+                                            const int16_t* filter_x,
+                                            int x_step_q4,
+                                            const int16_t* filter_y,
+                                            int y_step_q4,
+                                            int w,
+                                            int h);
 
-void vpx_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_avg_vert_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_avg_vert)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_avg_vert_c(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_avg_vert_sse2(const uint8_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint8_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h);
+void vpx_convolve8_avg_vert_ssse3(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
+RTCD_EXTERN void (*vpx_convolve8_avg_vert)(const uint8_t* src,
+                                           ptrdiff_t src_stride,
+                                           uint8_t* dst,
+                                           ptrdiff_t dst_stride,
+                                           const int16_t* filter_x,
+                                           int x_step_q4,
+                                           const int16_t* filter_y,
+                                           int y_step_q4,
+                                           int w,
+                                           int h);
 
-void vpx_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_horiz_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_horiz)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_horiz_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
+void vpx_convolve8_horiz_sse2(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_horiz_ssse3(const uint8_t* src,
+                               ptrdiff_t src_stride,
+                               uint8_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h);
+void vpx_convolve8_horiz_avx2(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+RTCD_EXTERN void (*vpx_convolve8_horiz)(const uint8_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint8_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h);
 
-void vpx_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve8_vert_avx2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_convolve8_vert)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve8_vert_c(const uint8_t* src,
+                          ptrdiff_t src_stride,
+                          uint8_t* dst,
+                          ptrdiff_t dst_stride,
+                          const int16_t* filter_x,
+                          int x_step_q4,
+                          const int16_t* filter_y,
+                          int y_step_q4,
+                          int w,
+                          int h);
+void vpx_convolve8_vert_sse2(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+void vpx_convolve8_vert_ssse3(const uint8_t* src,
+                              ptrdiff_t src_stride,
+                              uint8_t* dst,
+                              ptrdiff_t dst_stride,
+                              const int16_t* filter_x,
+                              int x_step_q4,
+                              const int16_t* filter_y,
+                              int y_step_q4,
+                              int w,
+                              int h);
+void vpx_convolve8_vert_avx2(const uint8_t* src,
+                             ptrdiff_t src_stride,
+                             uint8_t* dst,
+                             ptrdiff_t dst_stride,
+                             const int16_t* filter_x,
+                             int x_step_q4,
+                             const int16_t* filter_y,
+                             int y_step_q4,
+                             int w,
+                             int h);
+RTCD_EXTERN void (*vpx_convolve8_vert)(const uint8_t* src,
+                                       ptrdiff_t src_stride,
+                                       uint8_t* dst,
+                                       ptrdiff_t dst_stride,
+                                       const int16_t* filter_x,
+                                       int x_step_q4,
+                                       const int16_t* filter_y,
+                                       int y_step_q4,
+                                       int w,
+                                       int h);
 
-void vpx_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_avg_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_avg_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
+void vpx_convolve_avg_sse2(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_convolve_avg vpx_convolve_avg_sse2
 
-void vpx_convolve_copy_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_convolve_copy_sse2(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_convolve_copy_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+void vpx_convolve_copy_sse2(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_convolve_copy vpx_convolve_copy_sse2
 
-void vpx_d117_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_16x16 vpx_d117_predictor_16x16_c
 
-void vpx_d117_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d117_predictor_32x32 vpx_d117_predictor_32x32_c
 
-void vpx_d117_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_4x4 vpx_d117_predictor_4x4_c
 
-void vpx_d117_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d117_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d117_predictor_8x8 vpx_d117_predictor_8x8_c
 
-void vpx_d135_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_16x16 vpx_d135_predictor_16x16_c
 
-void vpx_d135_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d135_predictor_32x32 vpx_d135_predictor_32x32_c
 
-void vpx_d135_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_4x4 vpx_d135_predictor_4x4_c
 
-void vpx_d135_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d135_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d135_predictor_8x8 vpx_d135_predictor_8x8_c
 
-void vpx_d153_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d153_predictor_16x16_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_16x16)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d153_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d153_predictor_32x32_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_32x32)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d153_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_4x4_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d153_predictor_4x4_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_4x4)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d153_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d153_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d153_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d153_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d153_predictor_8x8_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d153_predictor_8x8)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d207_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_16x16_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d207_predictor_16x16_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_16x16)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d207_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_32x32_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_d207_predictor_32x32_ssse3(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_32x32)(uint8_t* dst,
+                                             ptrdiff_t y_stride,
+                                             const uint8_t* above,
+                                             const uint8_t* left);
 
-void vpx_d207_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d207_predictor_4x4_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_d207_predictor_4x4 vpx_d207_predictor_4x4_sse2
 
-void vpx_d207_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d207_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d207_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d207_predictor_8x8_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_d207_predictor_8x8_ssse3(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+RTCD_EXTERN void (*vpx_d207_predictor_8x8)(uint8_t* dst,
+                                           ptrdiff_t y_stride,
+                                           const uint8_t* above,
+                                           const uint8_t* left);
 
-void vpx_d45_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_16x16_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_16x16)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d45_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d45_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d45_predictor_32x32_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d45_predictor_32x32)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d45_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_4x4_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d45_predictor_4x4 vpx_d45_predictor_4x4_sse2
 
-void vpx_d45_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d45_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d45_predictor_8x8_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_d45_predictor_8x8 vpx_d45_predictor_8x8_sse2
 
-void vpx_d45e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d45e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d45e_predictor_4x4 vpx_d45e_predictor_4x4_c
 
-void vpx_d63_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_16x16_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_16x16)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_16x16_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d63_predictor_16x16_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_16x16)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d63_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_32x32_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_32x32)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_32x32_c(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
+void vpx_d63_predictor_32x32_ssse3(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_32x32)(uint8_t* dst,
+                                            ptrdiff_t y_stride,
+                                            const uint8_t* above,
+                                            const uint8_t* left);
 
-void vpx_d63_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_4x4_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_4x4)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_4x4_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d63_predictor_4x4_ssse3(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_4x4)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d63_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_d63_predictor_8x8_ssse3(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-RTCD_EXTERN void (*vpx_d63_predictor_8x8)(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63_predictor_8x8_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_d63_predictor_8x8_ssse3(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+RTCD_EXTERN void (*vpx_d63_predictor_8x8)(uint8_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint8_t* above,
+                                          const uint8_t* left);
 
-void vpx_d63e_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_d63e_predictor_4x4_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_d63e_predictor_4x4 vpx_d63e_predictor_4x4_c
 
-void vpx_dc_128_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_16x16_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_128_predictor_16x16 vpx_dc_128_predictor_16x16_sse2
 
-void vpx_dc_128_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_128_predictor_32x32_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_128_predictor_32x32 vpx_dc_128_predictor_32x32_sse2
 
-void vpx_dc_128_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_4x4_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_128_predictor_4x4 vpx_dc_128_predictor_4x4_sse2
 
-void vpx_dc_128_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_128_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_128_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_128_predictor_8x8_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_128_predictor_8x8 vpx_dc_128_predictor_8x8_sse2
 
-void vpx_dc_left_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_16x16_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_16x16_sse2(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
 #define vpx_dc_left_predictor_16x16 vpx_dc_left_predictor_16x16_sse2
 
-void vpx_dc_left_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_32x32_c(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
+void vpx_dc_left_predictor_32x32_sse2(uint8_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint8_t* above,
+                                      const uint8_t* left);
 #define vpx_dc_left_predictor_32x32 vpx_dc_left_predictor_32x32_sse2
 
-void vpx_dc_left_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_4x4_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_4x4_sse2(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
 #define vpx_dc_left_predictor_4x4 vpx_dc_left_predictor_4x4_sse2
 
-void vpx_dc_left_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_left_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_left_predictor_8x8_c(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
+void vpx_dc_left_predictor_8x8_sse2(uint8_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint8_t* above,
+                                    const uint8_t* left);
 #define vpx_dc_left_predictor_8x8 vpx_dc_left_predictor_8x8_sse2
 
-void vpx_dc_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_16x16_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_predictor_16x16 vpx_dc_predictor_16x16_sse2
 
-void vpx_dc_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_dc_predictor_32x32_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_dc_predictor_32x32 vpx_dc_predictor_32x32_sse2
 
-void vpx_dc_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_4x4_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_dc_predictor_4x4 vpx_dc_predictor_4x4_sse2
 
-void vpx_dc_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_dc_predictor_8x8_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_dc_predictor_8x8 vpx_dc_predictor_8x8_sse2
 
-void vpx_dc_top_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_16x16_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_16x16_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_top_predictor_16x16 vpx_dc_top_predictor_16x16_sse2
 
-void vpx_dc_top_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_32x32_c(uint8_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint8_t* above,
+                                  const uint8_t* left);
+void vpx_dc_top_predictor_32x32_sse2(uint8_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint8_t* above,
+                                     const uint8_t* left);
 #define vpx_dc_top_predictor_32x32 vpx_dc_top_predictor_32x32_sse2
 
-void vpx_dc_top_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_4x4_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_4x4_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_top_predictor_4x4 vpx_dc_top_predictor_4x4_sse2
 
-void vpx_dc_top_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_dc_top_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_dc_top_predictor_8x8_c(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
+void vpx_dc_top_predictor_8x8_sse2(uint8_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint8_t* above,
+                                   const uint8_t* left);
 #define vpx_dc_top_predictor_8x8 vpx_dc_top_predictor_8x8_sse2
 
-void vpx_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16 vpx_fdct16x16_sse2
 
-void vpx_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct16x16_1_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct16x16_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct16x16_1_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct16x16_1 vpx_fdct16x16_1_sse2
 
-void vpx_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32 vpx_fdct32x32_sse2
 
-void vpx_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_1_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_1_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct32x32_1 vpx_fdct32x32_1_sse2
 
-void vpx_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct32x32_rd_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct32x32_rd_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct32x32_rd_sse2(const int16_t* input,
+                           tran_low_t* output,
+                           int stride);
 #define vpx_fdct32x32_rd vpx_fdct32x32_rd_sse2
 
-void vpx_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4 vpx_fdct4x4_sse2
 
-void vpx_fdct4x4_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct4x4_1_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct4x4_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct4x4_1_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct4x4_1 vpx_fdct4x4_1_sse2
 
-void vpx_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8 vpx_fdct8x8_sse2
 
-void vpx_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_fdct8x8_1_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_fdct8x8_1_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_fdct8x8_1_sse2(const int16_t* input, tran_low_t* output, int stride);
 #define vpx_fdct8x8_1 vpx_fdct8x8_1_sse2
 
-void vpx_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get16x16var_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-RTCD_EXTERN void (*vpx_get16x16var)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get16x16var_c(const uint8_t* src_ptr,
+                       int source_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       unsigned int* sse,
+                       int* sum);
+void vpx_get16x16var_sse2(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
+void vpx_get16x16var_avx2(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          unsigned int* sse,
+                          int* sum);
+RTCD_EXTERN void (*vpx_get16x16var)(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse,
+                                    int* sum);
 
-unsigned int vpx_get4x4sse_cs_c(const unsigned char *src_ptr, int source_stride, const unsigned char *ref_ptr, int  ref_stride);
+unsigned int vpx_get4x4sse_cs_c(const unsigned char* src_ptr,
+                                int source_stride,
+                                const unsigned char* ref_ptr,
+                                int ref_stride);
 #define vpx_get4x4sse_cs vpx_get4x4sse_cs_c
 
-void vpx_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
-void vpx_get8x8var_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_get8x8var_c(const uint8_t* src_ptr,
+                     int source_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     unsigned int* sse,
+                     int* sum);
+void vpx_get8x8var_sse2(const uint8_t* src_ptr,
+                        int source_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        unsigned int* sse,
+                        int* sum);
 #define vpx_get8x8var vpx_get8x8var_sse2
 
-unsigned int vpx_get_mb_ss_c(const int16_t *);
-unsigned int vpx_get_mb_ss_sse2(const int16_t *);
+unsigned int vpx_get_mb_ss_c(const int16_t*);
+unsigned int vpx_get_mb_ss_sse2(const int16_t*);
 #define vpx_get_mb_ss vpx_get_mb_ss_sse2
 
-void vpx_h_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_16x16_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_h_predictor_16x16 vpx_h_predictor_16x16_sse2
 
-void vpx_h_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_h_predictor_32x32_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_h_predictor_32x32 vpx_h_predictor_32x32_sse2
 
-void vpx_h_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_4x4_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_h_predictor_4x4 vpx_h_predictor_4x4_sse2
 
-void vpx_h_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_h_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_h_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_h_predictor_8x8_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_h_predictor_8x8 vpx_h_predictor_8x8_sse2
 
-void vpx_hadamard_16x16_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_16x16_sse2(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_16x16_c(const int16_t* src_diff,
+                          int src_stride,
+                          tran_low_t* coeff);
+void vpx_hadamard_16x16_sse2(const int16_t* src_diff,
+                             int src_stride,
+                             tran_low_t* coeff);
 #define vpx_hadamard_16x16 vpx_hadamard_16x16_sse2
 
-void vpx_hadamard_8x8_c(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_8x8_sse2(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-void vpx_hadamard_8x8_ssse3(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
-RTCD_EXTERN void (*vpx_hadamard_8x8)(const int16_t *src_diff, int src_stride, tran_low_t *coeff);
+void vpx_hadamard_8x8_c(const int16_t* src_diff,
+                        int src_stride,
+                        tran_low_t* coeff);
+void vpx_hadamard_8x8_sse2(const int16_t* src_diff,
+                           int src_stride,
+                           tran_low_t* coeff);
+void vpx_hadamard_8x8_ssse3(const int16_t* src_diff,
+                            int src_stride,
+                            tran_low_t* coeff);
+RTCD_EXTERN void (*vpx_hadamard_8x8)(const int16_t* src_diff,
+                                     int src_stride,
+                                     tran_low_t* coeff);
 
-void vpx_he_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_he_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_he_predictor_4x4 vpx_he_predictor_4x4_c
 
-void vpx_highbd_10_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_10_get16x16var vpx_highbd_10_get16x16var_c
 
-void vpx_highbd_10_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_10_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_10_get8x8var vpx_highbd_10_get8x8var_c
 
-unsigned int vpx_highbd_10_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+unsigned int vpx_highbd_10_mse16x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_mse16x16 vpx_highbd_10_mse16x16_sse2
 
-unsigned int vpx_highbd_10_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse16x8 vpx_highbd_10_mse16x8_c
 
-unsigned int vpx_highbd_10_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_10_mse8x16 vpx_highbd_10_mse8x16_c
 
-unsigned int vpx_highbd_10_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
+unsigned int vpx_highbd_10_mse8x8_sse2(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
 #define vpx_highbd_10_mse8x8 vpx_highbd_10_mse8x8_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x16 vpx_highbd_10_sub_pixel_avg_variance16x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x16 \
+  vpx_highbd_10_sub_pixel_avg_variance16x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x32 vpx_highbd_10_sub_pixel_avg_variance16x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x32 \
+  vpx_highbd_10_sub_pixel_avg_variance16x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance16x8 vpx_highbd_10_sub_pixel_avg_variance16x8_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance16x8 \
+  vpx_highbd_10_sub_pixel_avg_variance16x8_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x16 vpx_highbd_10_sub_pixel_avg_variance32x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x16 \
+  vpx_highbd_10_sub_pixel_avg_variance32x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x32 vpx_highbd_10_sub_pixel_avg_variance32x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x32 \
+  vpx_highbd_10_sub_pixel_avg_variance32x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance32x64 vpx_highbd_10_sub_pixel_avg_variance32x64_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance32x64 \
+  vpx_highbd_10_sub_pixel_avg_variance32x64_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x4 vpx_highbd_10_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x4 \
+  vpx_highbd_10_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance4x8 vpx_highbd_10_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance4x8 \
+  vpx_highbd_10_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance64x32 vpx_highbd_10_sub_pixel_avg_variance64x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance64x32 \
+  vpx_highbd_10_sub_pixel_avg_variance64x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance64x64 vpx_highbd_10_sub_pixel_avg_variance64x64_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance64x64 \
+  vpx_highbd_10_sub_pixel_avg_variance64x64_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x16 vpx_highbd_10_sub_pixel_avg_variance8x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x16 \
+  vpx_highbd_10_sub_pixel_avg_variance8x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x4 vpx_highbd_10_sub_pixel_avg_variance8x4_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x4 \
+  vpx_highbd_10_sub_pixel_avg_variance8x4_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_10_sub_pixel_avg_variance8x8 vpx_highbd_10_sub_pixel_avg_variance8x8_sse2
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_10_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_10_sub_pixel_avg_variance8x8 \
+  vpx_highbd_10_sub_pixel_avg_variance8x8_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x16 vpx_highbd_10_sub_pixel_variance16x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x16 \
+  vpx_highbd_10_sub_pixel_variance16x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x32 vpx_highbd_10_sub_pixel_variance16x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x32 \
+  vpx_highbd_10_sub_pixel_variance16x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance16x8 vpx_highbd_10_sub_pixel_variance16x8_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance16x8 \
+  vpx_highbd_10_sub_pixel_variance16x8_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x16 vpx_highbd_10_sub_pixel_variance32x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x16 \
+  vpx_highbd_10_sub_pixel_variance32x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x32 vpx_highbd_10_sub_pixel_variance32x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x32 \
+  vpx_highbd_10_sub_pixel_variance32x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance32x64 vpx_highbd_10_sub_pixel_variance32x64_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance32x64 \
+  vpx_highbd_10_sub_pixel_variance32x64_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x4 vpx_highbd_10_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x4 \
+  vpx_highbd_10_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance4x8 vpx_highbd_10_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_10_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance4x8 \
+  vpx_highbd_10_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance64x32 vpx_highbd_10_sub_pixel_variance64x32_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance64x32 \
+  vpx_highbd_10_sub_pixel_variance64x32_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance64x64 vpx_highbd_10_sub_pixel_variance64x64_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance64x64 \
+  vpx_highbd_10_sub_pixel_variance64x64_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x16 vpx_highbd_10_sub_pixel_variance8x16_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x16 \
+  vpx_highbd_10_sub_pixel_variance8x16_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x4 vpx_highbd_10_sub_pixel_variance8x4_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x4 \
+  vpx_highbd_10_sub_pixel_variance8x4_sse2
 
-uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_10_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_10_sub_pixel_variance8x8 vpx_highbd_10_sub_pixel_variance8x8_sse2
+uint32_t vpx_highbd_10_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_10_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_10_sub_pixel_variance8x8 \
+  vpx_highbd_10_sub_pixel_variance8x8_sse2
 
-unsigned int vpx_highbd_10_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance16x16 vpx_highbd_10_variance16x16_sse2
 
-unsigned int vpx_highbd_10_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance16x32 vpx_highbd_10_variance16x32_sse2
 
-unsigned int vpx_highbd_10_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_10_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_10_variance16x8 vpx_highbd_10_variance16x8_sse2
 
-unsigned int vpx_highbd_10_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance32x16 vpx_highbd_10_variance32x16_sse2
 
-unsigned int vpx_highbd_10_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance32x32 vpx_highbd_10_variance32x32_sse2
 
-unsigned int vpx_highbd_10_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance32x64 vpx_highbd_10_variance32x64_sse2
 
-unsigned int vpx_highbd_10_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x4 vpx_highbd_10_variance4x4_c
 
-unsigned int vpx_highbd_10_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance4x8 vpx_highbd_10_variance4x8_c
 
-unsigned int vpx_highbd_10_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance64x32 vpx_highbd_10_variance64x32_sse2
 
-unsigned int vpx_highbd_10_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_10_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_10_variance64x64 vpx_highbd_10_variance64x64_sse2
 
-unsigned int vpx_highbd_10_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_10_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_10_variance8x16 vpx_highbd_10_variance8x16_sse2
 
-unsigned int vpx_highbd_10_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_10_variance8x4 vpx_highbd_10_variance8x4_c
 
-unsigned int vpx_highbd_10_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_10_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_10_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_10_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 #define vpx_highbd_10_variance8x8 vpx_highbd_10_variance8x8_sse2
 
-void vpx_highbd_12_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get16x16var_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse,
+                                 int* sum);
 #define vpx_highbd_12_get16x16var vpx_highbd_12_get16x16var_c
 
-void vpx_highbd_12_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_12_get8x8var_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse,
+                               int* sum);
 #define vpx_highbd_12_get8x8var vpx_highbd_12_get8x8var_c
 
-unsigned int vpx_highbd_12_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
+unsigned int vpx_highbd_12_mse16x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_mse16x16 vpx_highbd_12_mse16x16_sse2
 
-unsigned int vpx_highbd_12_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse16x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse16x8 vpx_highbd_12_mse16x8_c
 
-unsigned int vpx_highbd_12_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
 #define vpx_highbd_12_mse8x16 vpx_highbd_12_mse8x16_c
 
-unsigned int vpx_highbd_12_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_mse8x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
+unsigned int vpx_highbd_12_mse8x8_sse2(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       const uint8_t* ref_ptr,
+                                       int recon_stride,
+                                       unsigned int* sse);
 #define vpx_highbd_12_mse8x8 vpx_highbd_12_mse8x8_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x16 vpx_highbd_12_sub_pixel_avg_variance16x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x16 \
+  vpx_highbd_12_sub_pixel_avg_variance16x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x32 vpx_highbd_12_sub_pixel_avg_variance16x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x32 \
+  vpx_highbd_12_sub_pixel_avg_variance16x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance16x8 vpx_highbd_12_sub_pixel_avg_variance16x8_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance16x8 \
+  vpx_highbd_12_sub_pixel_avg_variance16x8_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x16 vpx_highbd_12_sub_pixel_avg_variance32x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x16 \
+  vpx_highbd_12_sub_pixel_avg_variance32x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x32 vpx_highbd_12_sub_pixel_avg_variance32x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x32 \
+  vpx_highbd_12_sub_pixel_avg_variance32x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance32x64 vpx_highbd_12_sub_pixel_avg_variance32x64_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance32x64 \
+  vpx_highbd_12_sub_pixel_avg_variance32x64_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x4 vpx_highbd_12_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x4 \
+  vpx_highbd_12_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance4x8 vpx_highbd_12_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance4x8 \
+  vpx_highbd_12_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance64x32 vpx_highbd_12_sub_pixel_avg_variance64x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance64x32 \
+  vpx_highbd_12_sub_pixel_avg_variance64x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance64x64 vpx_highbd_12_sub_pixel_avg_variance64x64_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_c(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance64x64 \
+  vpx_highbd_12_sub_pixel_avg_variance64x64_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x16 vpx_highbd_12_sub_pixel_avg_variance8x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x16 \
+  vpx_highbd_12_sub_pixel_avg_variance8x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x4 vpx_highbd_12_sub_pixel_avg_variance8x4_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x4 \
+  vpx_highbd_12_sub_pixel_avg_variance8x4_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_12_sub_pixel_avg_variance8x8 vpx_highbd_12_sub_pixel_avg_variance8x8_sse2
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_12_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_12_sub_pixel_avg_variance8x8 \
+  vpx_highbd_12_sub_pixel_avg_variance8x8_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x16 vpx_highbd_12_sub_pixel_variance16x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x16 \
+  vpx_highbd_12_sub_pixel_variance16x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x32 vpx_highbd_12_sub_pixel_variance16x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x32 \
+  vpx_highbd_12_sub_pixel_variance16x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance16x8 vpx_highbd_12_sub_pixel_variance16x8_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance16x8 \
+  vpx_highbd_12_sub_pixel_variance16x8_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x16 vpx_highbd_12_sub_pixel_variance32x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x16 \
+  vpx_highbd_12_sub_pixel_variance32x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x32 vpx_highbd_12_sub_pixel_variance32x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x32 \
+  vpx_highbd_12_sub_pixel_variance32x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance32x64 vpx_highbd_12_sub_pixel_variance32x64_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance32x64 \
+  vpx_highbd_12_sub_pixel_variance32x64_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x4 vpx_highbd_12_sub_pixel_variance4x4_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x4 \
+  vpx_highbd_12_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance4x8 vpx_highbd_12_sub_pixel_variance4x8_c
+uint32_t vpx_highbd_12_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance4x8 \
+  vpx_highbd_12_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance64x32 vpx_highbd_12_sub_pixel_variance64x32_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance64x32 \
+  vpx_highbd_12_sub_pixel_variance64x32_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance64x64 vpx_highbd_12_sub_pixel_variance64x64_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance64x64 \
+  vpx_highbd_12_sub_pixel_variance64x64_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x16 vpx_highbd_12_sub_pixel_variance8x16_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x16 \
+  vpx_highbd_12_sub_pixel_variance8x16_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x4 vpx_highbd_12_sub_pixel_variance8x4_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x4 \
+  vpx_highbd_12_sub_pixel_variance8x4_sse2
 
-uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_12_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_12_sub_pixel_variance8x8 vpx_highbd_12_sub_pixel_variance8x8_sse2
+uint32_t vpx_highbd_12_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_12_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_12_sub_pixel_variance8x8 \
+  vpx_highbd_12_sub_pixel_variance8x8_sse2
 
-unsigned int vpx_highbd_12_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance16x16 vpx_highbd_12_variance16x16_sse2
 
-unsigned int vpx_highbd_12_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance16x32 vpx_highbd_12_variance16x32_sse2
 
-unsigned int vpx_highbd_12_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_12_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_12_variance16x8 vpx_highbd_12_variance16x8_sse2
 
-unsigned int vpx_highbd_12_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance32x16 vpx_highbd_12_variance32x16_sse2
 
-unsigned int vpx_highbd_12_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance32x32 vpx_highbd_12_variance32x32_sse2
 
-unsigned int vpx_highbd_12_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance32x64 vpx_highbd_12_variance32x64_sse2
 
-unsigned int vpx_highbd_12_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x4 vpx_highbd_12_variance4x4_c
 
-unsigned int vpx_highbd_12_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance4x8 vpx_highbd_12_variance4x8_c
 
-unsigned int vpx_highbd_12_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance64x32 vpx_highbd_12_variance64x32_sse2
 
-unsigned int vpx_highbd_12_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
+unsigned int vpx_highbd_12_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 #define vpx_highbd_12_variance64x64 vpx_highbd_12_variance64x64_sse2
 
-unsigned int vpx_highbd_12_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_12_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_12_variance8x16 vpx_highbd_12_variance8x16_sse2
 
-unsigned int vpx_highbd_12_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
 #define vpx_highbd_12_variance8x4 vpx_highbd_12_variance8x4_c
 
-unsigned int vpx_highbd_12_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_12_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_12_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_12_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 #define vpx_highbd_12_variance8x8 vpx_highbd_12_variance8x8_sse2
 
-void vpx_highbd_8_get16x16var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get16x16var_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse,
+                                int* sum);
 #define vpx_highbd_8_get16x16var vpx_highbd_8_get16x16var_c
 
-void vpx_highbd_8_get8x8var_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse, int *sum);
+void vpx_highbd_8_get8x8var_c(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              unsigned int* sse,
+                              int* sum);
 #define vpx_highbd_8_get8x8var vpx_highbd_8_get8x8var_c
 
-unsigned int vpx_highbd_8_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x16_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     const uint8_t* ref_ptr,
+                                     int recon_stride,
+                                     unsigned int* sse);
+unsigned int vpx_highbd_8_mse16x16_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int recon_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_mse16x16 vpx_highbd_8_mse16x16_sse2
 
-unsigned int vpx_highbd_8_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse16x8_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse16x8 vpx_highbd_8_mse16x8_c
 
-unsigned int vpx_highbd_8_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x16_c(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int recon_stride,
+                                    unsigned int* sse);
 #define vpx_highbd_8_mse8x16 vpx_highbd_8_mse8x16_c
 
-unsigned int vpx_highbd_8_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_mse8x8_c(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int recon_stride,
+                                   unsigned int* sse);
+unsigned int vpx_highbd_8_mse8x8_sse2(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      const uint8_t* ref_ptr,
+                                      int recon_stride,
+                                      unsigned int* sse);
 #define vpx_highbd_8_mse8x8 vpx_highbd_8_mse8x8_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x16 vpx_highbd_8_sub_pixel_avg_variance16x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x16 \
+  vpx_highbd_8_sub_pixel_avg_variance16x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x32 vpx_highbd_8_sub_pixel_avg_variance16x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x32 \
+  vpx_highbd_8_sub_pixel_avg_variance16x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance16x8 vpx_highbd_8_sub_pixel_avg_variance16x8_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance16x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance16x8 \
+  vpx_highbd_8_sub_pixel_avg_variance16x8_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x16 vpx_highbd_8_sub_pixel_avg_variance32x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x16 \
+  vpx_highbd_8_sub_pixel_avg_variance32x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x32 vpx_highbd_8_sub_pixel_avg_variance32x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x32 \
+  vpx_highbd_8_sub_pixel_avg_variance32x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance32x64 vpx_highbd_8_sub_pixel_avg_variance32x64_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance32x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance32x64 \
+  vpx_highbd_8_sub_pixel_avg_variance32x64_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x4 vpx_highbd_8_sub_pixel_avg_variance4x4_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x4 \
+  vpx_highbd_8_sub_pixel_avg_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance4x8 vpx_highbd_8_sub_pixel_avg_variance4x8_c
+uint32_t vpx_highbd_8_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance4x8 \
+  vpx_highbd_8_sub_pixel_avg_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance64x32 vpx_highbd_8_sub_pixel_avg_variance64x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x32_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance64x32 \
+  vpx_highbd_8_sub_pixel_avg_variance64x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance64x64 vpx_highbd_8_sub_pixel_avg_variance64x64_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse,
+                                                    const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance64x64_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance64x64 \
+  vpx_highbd_8_sub_pixel_avg_variance64x64_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x16 vpx_highbd_8_sub_pixel_avg_variance8x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse,
+                                                   const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x16_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x16 \
+  vpx_highbd_8_sub_pixel_avg_variance8x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x4 vpx_highbd_8_sub_pixel_avg_variance8x4_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x4_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x4 \
+  vpx_highbd_8_sub_pixel_avg_variance8x4_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-#define vpx_highbd_8_sub_pixel_avg_variance8x8 vpx_highbd_8_sub_pixel_avg_variance8x8_sse2
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse,
+                                                  const uint8_t* second_pred);
+uint32_t vpx_highbd_8_sub_pixel_avg_variance8x8_sse2(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
+#define vpx_highbd_8_sub_pixel_avg_variance8x8 \
+  vpx_highbd_8_sub_pixel_avg_variance8x8_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x16 vpx_highbd_8_sub_pixel_variance16x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x16 \
+  vpx_highbd_8_sub_pixel_variance16x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x32 vpx_highbd_8_sub_pixel_variance16x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x32 \
+  vpx_highbd_8_sub_pixel_variance16x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance16x8 vpx_highbd_8_sub_pixel_variance16x8_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance16x8 \
+  vpx_highbd_8_sub_pixel_variance16x8_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x16 vpx_highbd_8_sub_pixel_variance32x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x16 \
+  vpx_highbd_8_sub_pixel_variance32x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x32 vpx_highbd_8_sub_pixel_variance32x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x32 \
+  vpx_highbd_8_sub_pixel_variance32x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance32x64 vpx_highbd_8_sub_pixel_variance32x64_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance32x64 \
+  vpx_highbd_8_sub_pixel_variance32x64_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x4 vpx_highbd_8_sub_pixel_variance4x4_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_highbd_8_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
 #define vpx_highbd_8_sub_pixel_variance4x8 vpx_highbd_8_sub_pixel_variance4x8_c
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance64x32 vpx_highbd_8_sub_pixel_variance64x32_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance64x32 \
+  vpx_highbd_8_sub_pixel_variance64x32_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance64x64 vpx_highbd_8_sub_pixel_variance64x64_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                                int source_stride,
+                                                int xoffset,
+                                                int yoffset,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride,
+                                                uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance64x64 \
+  vpx_highbd_8_sub_pixel_variance64x64_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance8x16 vpx_highbd_8_sub_pixel_variance8x16_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance8x16 \
+  vpx_highbd_8_sub_pixel_variance8x16_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance8x4 vpx_highbd_8_sub_pixel_variance8x4_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance8x4 \
+  vpx_highbd_8_sub_pixel_variance8x4_sse2
 
-uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_highbd_8_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-#define vpx_highbd_8_sub_pixel_variance8x8 vpx_highbd_8_sub_pixel_variance8x8_sse2
+uint32_t vpx_highbd_8_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse);
+uint32_t vpx_highbd_8_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                                 int source_stride,
+                                                 int xoffset,
+                                                 int yoffset,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride,
+                                                 uint32_t* sse);
+#define vpx_highbd_8_sub_pixel_variance8x8 \
+  vpx_highbd_8_sub_pixel_variance8x8_sse2
 
-unsigned int vpx_highbd_8_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance16x16 vpx_highbd_8_variance16x16_sse2
 
-unsigned int vpx_highbd_8_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance16x32 vpx_highbd_8_variance16x32_sse2
 
-unsigned int vpx_highbd_8_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance16x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_8_variance16x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 #define vpx_highbd_8_variance16x8 vpx_highbd_8_variance16x8_sse2
 
-unsigned int vpx_highbd_8_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance32x16 vpx_highbd_8_variance32x16_sse2
 
-unsigned int vpx_highbd_8_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance32x32 vpx_highbd_8_variance32x32_sse2
 
-unsigned int vpx_highbd_8_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance32x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance32x64_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance32x64 vpx_highbd_8_variance32x64_sse2
 
-unsigned int vpx_highbd_8_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x4 vpx_highbd_8_variance4x4_c
 
-unsigned int vpx_highbd_8_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance4x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance4x8 vpx_highbd_8_variance4x8_c
 
-unsigned int vpx_highbd_8_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x32_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance64x32_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance64x32 vpx_highbd_8_variance64x32_sse2
 
-unsigned int vpx_highbd_8_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance64x64_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          unsigned int* sse);
+unsigned int vpx_highbd_8_variance64x64_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             unsigned int* sse);
 #define vpx_highbd_8_variance64x64 vpx_highbd_8_variance64x64_sse2
 
-unsigned int vpx_highbd_8_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x16_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         unsigned int* sse);
+unsigned int vpx_highbd_8_variance8x16_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            unsigned int* sse);
 #define vpx_highbd_8_variance8x16 vpx_highbd_8_variance8x16_sse2
 
-unsigned int vpx_highbd_8_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x4_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
 #define vpx_highbd_8_variance8x4 vpx_highbd_8_variance8x4_c
 
-unsigned int vpx_highbd_8_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_highbd_8_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_highbd_8_variance8x8_c(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        unsigned int* sse);
+unsigned int vpx_highbd_8_variance8x8_sse2(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           unsigned int* sse);
 #define vpx_highbd_8_variance8x8 vpx_highbd_8_variance8x8_sse2
 
-unsigned int vpx_highbd_avg_4x4_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_4x4_c(const uint8_t*, int p);
 #define vpx_highbd_avg_4x4 vpx_highbd_avg_4x4_c
 
-unsigned int vpx_highbd_avg_8x8_c(const uint8_t *, int p);
+unsigned int vpx_highbd_avg_8x8_c(const uint8_t*, int p);
 #define vpx_highbd_avg_8x8 vpx_highbd_avg_8x8_c
 
-void vpx_highbd_comp_avg_pred_c(uint16_t *comp_pred, const uint8_t *pred8, int width, int height, const uint8_t *ref8, int ref_stride);
+void vpx_highbd_comp_avg_pred_c(uint16_t* comp_pred,
+                                const uint8_t* pred8,
+                                int width,
+                                int height,
+                                const uint8_t* ref8,
+                                int ref_stride);
 #define vpx_highbd_comp_avg_pred vpx_highbd_comp_avg_pred_c
 
-void vpx_highbd_convolve8_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_c(const uint16_t* src,
+                            ptrdiff_t src_stride,
+                            uint16_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h,
+                            int bps);
+void vpx_highbd_convolve8_sse2(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+void vpx_highbd_convolve8_avx2(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8)(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
 
-void vpx_highbd_convolve8_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
+void vpx_highbd_convolve8_avg_sse2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+void vpx_highbd_convolve8_avg_avx2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg)(const uint16_t* src,
+                                             ptrdiff_t src_stride,
+                                             uint16_t* dst,
+                                             ptrdiff_t dst_stride,
+                                             const int16_t* filter_x,
+                                             int x_step_q4,
+                                             const int16_t* filter_y,
+                                             int y_step_q4,
+                                             int w,
+                                             int h,
+                                             int bps);
 
-void vpx_highbd_convolve8_avg_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_horiz_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_horiz_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg_horiz)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_horiz_c(const uint16_t* src,
+                                      ptrdiff_t src_stride,
+                                      uint16_t* dst,
+                                      ptrdiff_t dst_stride,
+                                      const int16_t* filter_x,
+                                      int x_step_q4,
+                                      const int16_t* filter_y,
+                                      int y_step_q4,
+                                      int w,
+                                      int h,
+                                      int bps);
+void vpx_highbd_convolve8_avg_horiz_sse2(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
+void vpx_highbd_convolve8_avg_horiz_avx2(const uint16_t* src,
+                                         ptrdiff_t src_stride,
+                                         uint16_t* dst,
+                                         ptrdiff_t dst_stride,
+                                         const int16_t* filter_x,
+                                         int x_step_q4,
+                                         const int16_t* filter_y,
+                                         int y_step_q4,
+                                         int w,
+                                         int h,
+                                         int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg_horiz)(const uint16_t* src,
+                                                   ptrdiff_t src_stride,
+                                                   uint16_t* dst,
+                                                   ptrdiff_t dst_stride,
+                                                   const int16_t* filter_x,
+                                                   int x_step_q4,
+                                                   const int16_t* filter_y,
+                                                   int y_step_q4,
+                                                   int w,
+                                                   int h,
+                                                   int bps);
 
-void vpx_highbd_convolve8_avg_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_vert_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_avg_vert_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_avg_vert)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_avg_vert_c(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+void vpx_highbd_convolve8_avg_vert_sse2(const uint16_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint16_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h,
+                                        int bps);
+void vpx_highbd_convolve8_avg_vert_avx2(const uint16_t* src,
+                                        ptrdiff_t src_stride,
+                                        uint16_t* dst,
+                                        ptrdiff_t dst_stride,
+                                        const int16_t* filter_x,
+                                        int x_step_q4,
+                                        const int16_t* filter_y,
+                                        int y_step_q4,
+                                        int w,
+                                        int h,
+                                        int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_avg_vert)(const uint16_t* src,
+                                                  ptrdiff_t src_stride,
+                                                  uint16_t* dst,
+                                                  ptrdiff_t dst_stride,
+                                                  const int16_t* filter_x,
+                                                  int x_step_q4,
+                                                  const int16_t* filter_y,
+                                                  int y_step_q4,
+                                                  int w,
+                                                  int h,
+                                                  int bps);
 
-void vpx_highbd_convolve8_horiz_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_horiz_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_horiz_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_horiz)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_horiz_c(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+void vpx_highbd_convolve8_horiz_sse2(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+void vpx_highbd_convolve8_horiz_avx2(const uint16_t* src,
+                                     ptrdiff_t src_stride,
+                                     uint16_t* dst,
+                                     ptrdiff_t dst_stride,
+                                     const int16_t* filter_x,
+                                     int x_step_q4,
+                                     const int16_t* filter_y,
+                                     int y_step_q4,
+                                     int w,
+                                     int h,
+                                     int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_horiz)(const uint16_t* src,
+                                               ptrdiff_t src_stride,
+                                               uint16_t* dst,
+                                               ptrdiff_t dst_stride,
+                                               const int16_t* filter_x,
+                                               int x_step_q4,
+                                               const int16_t* filter_y,
+                                               int y_step_q4,
+                                               int w,
+                                               int h,
+                                               int bps);
 
-void vpx_highbd_convolve8_vert_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_vert_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve8_vert_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve8_vert)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve8_vert_c(const uint16_t* src,
+                                 ptrdiff_t src_stride,
+                                 uint16_t* dst,
+                                 ptrdiff_t dst_stride,
+                                 const int16_t* filter_x,
+                                 int x_step_q4,
+                                 const int16_t* filter_y,
+                                 int y_step_q4,
+                                 int w,
+                                 int h,
+                                 int bps);
+void vpx_highbd_convolve8_vert_sse2(const uint16_t* src,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst,
+                                    ptrdiff_t dst_stride,
+                                    const int16_t* filter_x,
+                                    int x_step_q4,
+                                    const int16_t* filter_y,
+                                    int y_step_q4,
+                                    int w,
+                                    int h,
+                                    int bps);
+void vpx_highbd_convolve8_vert_avx2(const uint16_t* src,
+                                    ptrdiff_t src_stride,
+                                    uint16_t* dst,
+                                    ptrdiff_t dst_stride,
+                                    const int16_t* filter_x,
+                                    int x_step_q4,
+                                    const int16_t* filter_y,
+                                    int y_step_q4,
+                                    int w,
+                                    int h,
+                                    int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve8_vert)(const uint16_t* src,
+                                              ptrdiff_t src_stride,
+                                              uint16_t* dst,
+                                              ptrdiff_t dst_stride,
+                                              const int16_t* filter_x,
+                                              int x_step_q4,
+                                              const int16_t* filter_y,
+                                              int y_step_q4,
+                                              int w,
+                                              int h,
+                                              int bps);
 
-void vpx_highbd_convolve_avg_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_avg_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_avg_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve_avg)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_avg_c(const uint16_t* src,
+                               ptrdiff_t src_stride,
+                               uint16_t* dst,
+                               ptrdiff_t dst_stride,
+                               const int16_t* filter_x,
+                               int x_step_q4,
+                               const int16_t* filter_y,
+                               int y_step_q4,
+                               int w,
+                               int h,
+                               int bps);
+void vpx_highbd_convolve_avg_sse2(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+void vpx_highbd_convolve_avg_avx2(const uint16_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint16_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h,
+                                  int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve_avg)(const uint16_t* src,
+                                            ptrdiff_t src_stride,
+                                            uint16_t* dst,
+                                            ptrdiff_t dst_stride,
+                                            const int16_t* filter_x,
+                                            int x_step_q4,
+                                            const int16_t* filter_y,
+                                            int y_step_q4,
+                                            int w,
+                                            int h,
+                                            int bps);
 
-void vpx_highbd_convolve_copy_c(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_copy_sse2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-void vpx_highbd_convolve_copy_avx2(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
-RTCD_EXTERN void (*vpx_highbd_convolve_copy)(const uint16_t *src, ptrdiff_t src_stride, uint16_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h, int bps);
+void vpx_highbd_convolve_copy_c(const uint16_t* src,
+                                ptrdiff_t src_stride,
+                                uint16_t* dst,
+                                ptrdiff_t dst_stride,
+                                const int16_t* filter_x,
+                                int x_step_q4,
+                                const int16_t* filter_y,
+                                int y_step_q4,
+                                int w,
+                                int h,
+                                int bps);
+void vpx_highbd_convolve_copy_sse2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+void vpx_highbd_convolve_copy_avx2(const uint16_t* src,
+                                   ptrdiff_t src_stride,
+                                   uint16_t* dst,
+                                   ptrdiff_t dst_stride,
+                                   const int16_t* filter_x,
+                                   int x_step_q4,
+                                   const int16_t* filter_y,
+                                   int y_step_q4,
+                                   int w,
+                                   int h,
+                                   int bps);
+RTCD_EXTERN void (*vpx_highbd_convolve_copy)(const uint16_t* src,
+                                             ptrdiff_t src_stride,
+                                             uint16_t* dst,
+                                             ptrdiff_t dst_stride,
+                                             const int16_t* filter_x,
+                                             int x_step_q4,
+                                             const int16_t* filter_y,
+                                             int y_step_q4,
+                                             int w,
+                                             int h,
+                                             int bps);
 
-void vpx_highbd_d117_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_16x16 vpx_highbd_d117_predictor_16x16_c
 
-void vpx_highbd_d117_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d117_predictor_32x32 vpx_highbd_d117_predictor_32x32_c
 
-void vpx_highbd_d117_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_4x4 vpx_highbd_d117_predictor_4x4_c
 
-void vpx_highbd_d117_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d117_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d117_predictor_8x8 vpx_highbd_d117_predictor_8x8_c
 
-void vpx_highbd_d135_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_16x16 vpx_highbd_d135_predictor_16x16_c
 
-void vpx_highbd_d135_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d135_predictor_32x32 vpx_highbd_d135_predictor_32x32_c
 
-void vpx_highbd_d135_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_4x4 vpx_highbd_d135_predictor_4x4_c
 
-void vpx_highbd_d135_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d135_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d135_predictor_8x8 vpx_highbd_d135_predictor_8x8_c
 
-void vpx_highbd_d153_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_16x16 vpx_highbd_d153_predictor_16x16_c
 
-void vpx_highbd_d153_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d153_predictor_32x32 vpx_highbd_d153_predictor_32x32_c
 
-void vpx_highbd_d153_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_4x4 vpx_highbd_d153_predictor_4x4_c
 
-void vpx_highbd_d153_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d153_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d153_predictor_8x8 vpx_highbd_d153_predictor_8x8_c
 
-void vpx_highbd_d207_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_16x16_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_16x16 vpx_highbd_d207_predictor_16x16_c
 
-void vpx_highbd_d207_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_32x32_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_d207_predictor_32x32 vpx_highbd_d207_predictor_32x32_c
 
-void vpx_highbd_d207_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_4x4_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_4x4 vpx_highbd_d207_predictor_4x4_c
 
-void vpx_highbd_d207_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d207_predictor_8x8_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_d207_predictor_8x8 vpx_highbd_d207_predictor_8x8_c
 
-void vpx_highbd_d45_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_16x16 vpx_highbd_d45_predictor_16x16_c
 
-void vpx_highbd_d45_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d45_predictor_32x32 vpx_highbd_d45_predictor_32x32_c
 
-void vpx_highbd_d45_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_4x4 vpx_highbd_d45_predictor_4x4_c
 
-void vpx_highbd_d45_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d45_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d45_predictor_8x8 vpx_highbd_d45_predictor_8x8_c
 
-void vpx_highbd_d63_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_16x16_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_16x16 vpx_highbd_d63_predictor_16x16_c
 
-void vpx_highbd_d63_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_32x32_c(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_d63_predictor_32x32 vpx_highbd_d63_predictor_32x32_c
 
-void vpx_highbd_d63_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_4x4_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_4x4 vpx_highbd_d63_predictor_4x4_c
 
-void vpx_highbd_d63_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_d63_predictor_8x8_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_d63_predictor_8x8 vpx_highbd_d63_predictor_8x8_c
 
-void vpx_highbd_dc_128_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_16x16 vpx_highbd_dc_128_predictor_16x16_c
 
-void vpx_highbd_dc_128_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_128_predictor_32x32 vpx_highbd_dc_128_predictor_32x32_c
 
-void vpx_highbd_dc_128_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_4x4 vpx_highbd_dc_128_predictor_4x4_c
 
-void vpx_highbd_dc_128_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_128_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_128_predictor_8x8 vpx_highbd_dc_128_predictor_8x8_c
 
-void vpx_highbd_dc_left_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_16x16_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_16x16 vpx_highbd_dc_left_predictor_16x16_c
 
-void vpx_highbd_dc_left_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_32x32_c(uint16_t* dst,
+                                          ptrdiff_t y_stride,
+                                          const uint16_t* above,
+                                          const uint16_t* left,
+                                          int bd);
 #define vpx_highbd_dc_left_predictor_32x32 vpx_highbd_dc_left_predictor_32x32_c
 
-void vpx_highbd_dc_left_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_4x4_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_4x4 vpx_highbd_dc_left_predictor_4x4_c
 
-void vpx_highbd_dc_left_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_left_predictor_8x8_c(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_left_predictor_8x8 vpx_highbd_dc_left_predictor_8x8_c
 
-void vpx_highbd_dc_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_dc_predictor_16x16_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_predictor_16x16 vpx_highbd_dc_predictor_16x16_sse2
 
-void vpx_highbd_dc_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_dc_predictor_32x32_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_dc_predictor_32x32 vpx_highbd_dc_predictor_32x32_sse2
 
-void vpx_highbd_dc_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_dc_predictor_4x4_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_dc_predictor_4x4 vpx_highbd_dc_predictor_4x4_sse2
 
-void vpx_highbd_dc_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_dc_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_dc_predictor_8x8_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_dc_predictor_8x8 vpx_highbd_dc_predictor_8x8_sse2
 
-void vpx_highbd_dc_top_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_16x16_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_16x16 vpx_highbd_dc_top_predictor_16x16_c
 
-void vpx_highbd_dc_top_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_32x32_c(uint16_t* dst,
+                                         ptrdiff_t y_stride,
+                                         const uint16_t* above,
+                                         const uint16_t* left,
+                                         int bd);
 #define vpx_highbd_dc_top_predictor_32x32 vpx_highbd_dc_top_predictor_32x32_c
 
-void vpx_highbd_dc_top_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_4x4_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_4x4 vpx_highbd_dc_top_predictor_4x4_c
 
-void vpx_highbd_dc_top_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_dc_top_predictor_8x8_c(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_dc_top_predictor_8x8 vpx_highbd_dc_top_predictor_8x8_c
 
-void vpx_highbd_fdct16x16_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct16x16_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
+void vpx_highbd_fdct16x16_sse2(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
 #define vpx_highbd_fdct16x16 vpx_highbd_fdct16x16_sse2
 
-void vpx_highbd_fdct16x16_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct16x16_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct16x16_1 vpx_highbd_fdct16x16_1_c
 
-void vpx_highbd_fdct32x32_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct32x32_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
+void vpx_highbd_fdct32x32_sse2(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
 #define vpx_highbd_fdct32x32 vpx_highbd_fdct32x32_sse2
 
-void vpx_highbd_fdct32x32_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_1_c(const int16_t* input,
+                              tran_low_t* output,
+                              int stride);
 #define vpx_highbd_fdct32x32_1 vpx_highbd_fdct32x32_1_c
 
-void vpx_highbd_fdct32x32_rd_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct32x32_rd_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct32x32_rd_c(const int16_t* input,
+                               tran_low_t* output,
+                               int stride);
+void vpx_highbd_fdct32x32_rd_sse2(const int16_t* input,
+                                  tran_low_t* output,
+                                  int stride);
 #define vpx_highbd_fdct32x32_rd vpx_highbd_fdct32x32_rd_sse2
 
-void vpx_highbd_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct4x4_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct4x4_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_highbd_fdct4x4_sse2(const int16_t* input,
+                             tran_low_t* output,
+                             int stride);
 #define vpx_highbd_fdct4x4 vpx_highbd_fdct4x4_sse2
 
-void vpx_highbd_fdct8x8_c(const int16_t *input, tran_low_t *output, int stride);
-void vpx_highbd_fdct8x8_sse2(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_c(const int16_t* input, tran_low_t* output, int stride);
+void vpx_highbd_fdct8x8_sse2(const int16_t* input,
+                             tran_low_t* output,
+                             int stride);
 #define vpx_highbd_fdct8x8 vpx_highbd_fdct8x8_sse2
 
-void vpx_highbd_fdct8x8_1_c(const int16_t *input, tran_low_t *output, int stride);
+void vpx_highbd_fdct8x8_1_c(const int16_t* input,
+                            tran_low_t* output,
+                            int stride);
 #define vpx_highbd_fdct8x8_1 vpx_highbd_fdct8x8_1_c
 
-void vpx_highbd_h_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_16x16 vpx_highbd_h_predictor_16x16_c
 
-void vpx_highbd_h_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
 #define vpx_highbd_h_predictor_32x32 vpx_highbd_h_predictor_32x32_c
 
-void vpx_highbd_h_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_4x4 vpx_highbd_h_predictor_4x4_c
 
-void vpx_highbd_h_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_h_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
 #define vpx_highbd_h_predictor_8x8 vpx_highbd_h_predictor_8x8_c
 
-void vpx_highbd_idct16x16_10_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_10_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_10_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+void vpx_highbd_idct16x16_10_add_sse2(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
 #define vpx_highbd_idct16x16_10_add vpx_highbd_idct16x16_10_add_sse2
 
-void vpx_highbd_idct16x16_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
+void vpx_highbd_idct16x16_1_add_sse2(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
 #define vpx_highbd_idct16x16_1_add vpx_highbd_idct16x16_1_add_sse2
 
-void vpx_highbd_idct16x16_256_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct16x16_256_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t* input,
+                                       uint16_t* dest,
+                                       int stride,
+                                       int bd);
 #define vpx_highbd_idct16x16_256_add vpx_highbd_idct16x16_256_add_sse2
 
-void vpx_highbd_idct16x16_38_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct16x16_256_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-#define vpx_highbd_idct16x16_38_add vpx_highbd_idct16x16_256_add_sse2
+void vpx_highbd_idct16x16_38_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
+void vpx_highbd_idct16x16_38_add_sse2(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+#define vpx_highbd_idct16x16_38_add vpx_highbd_idct16x16_38_add_sse2
 
-void vpx_highbd_idct32x32_1024_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1024_add_c(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
 #define vpx_highbd_idct32x32_1024_add vpx_highbd_idct32x32_1024_add_c
 
-void vpx_highbd_idct32x32_135_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_135_add_c(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
 #define vpx_highbd_idct32x32_135_add vpx_highbd_idct32x32_135_add_c
 
-void vpx_highbd_idct32x32_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct32x32_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_1_add_c(const tran_low_t* input,
+                                  uint16_t* dest,
+                                  int stride,
+                                  int bd);
+void vpx_highbd_idct32x32_1_add_sse2(const tran_low_t* input,
+                                     uint16_t* dest,
+                                     int stride,
+                                     int bd);
 #define vpx_highbd_idct32x32_1_add vpx_highbd_idct32x32_1_add_sse2
 
-void vpx_highbd_idct32x32_34_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct32x32_34_add_c(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct32x32_34_add vpx_highbd_idct32x32_34_add_c
 
-void vpx_highbd_idct4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_16_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_16_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct4x4_16_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct4x4_16_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct4x4_16_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct4x4_16_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_idct4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct4x4_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
+void vpx_highbd_idct4x4_1_add_sse2(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct4x4_1_add vpx_highbd_idct4x4_1_add_sse2
 
-void vpx_highbd_idct8x8_12_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_12_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_12_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_12_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_12_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct8x8_12_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct8x8_12_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_12_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_idct8x8_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_1_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
+void vpx_highbd_idct8x8_1_add_sse2(const tran_low_t* input,
+                                   uint16_t* dest,
+                                   int stride,
+                                   int bd);
 #define vpx_highbd_idct8x8_1_add vpx_highbd_idct8x8_1_add_sse2
 
-void vpx_highbd_idct8x8_64_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_64_add_sse2(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-void vpx_highbd_idct8x8_64_add_sse4_1(const tran_low_t *input, uint16_t *dest, int stride, int bd);
-RTCD_EXTERN void (*vpx_highbd_idct8x8_64_add)(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_idct8x8_64_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
+void vpx_highbd_idct8x8_64_add_sse2(const tran_low_t* input,
+                                    uint16_t* dest,
+                                    int stride,
+                                    int bd);
+void vpx_highbd_idct8x8_64_add_sse4_1(const tran_low_t* input,
+                                      uint16_t* dest,
+                                      int stride,
+                                      int bd);
+RTCD_EXTERN void (*vpx_highbd_idct8x8_64_add)(const tran_low_t* input,
+                                              uint16_t* dest,
+                                              int stride,
+                                              int bd);
 
-void vpx_highbd_iwht4x4_16_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_16_add_c(const tran_low_t* input,
+                                 uint16_t* dest,
+                                 int stride,
+                                 int bd);
 #define vpx_highbd_iwht4x4_16_add vpx_highbd_iwht4x4_16_add_c
 
-void vpx_highbd_iwht4x4_1_add_c(const tran_low_t *input, uint16_t *dest, int stride, int bd);
+void vpx_highbd_iwht4x4_1_add_c(const tran_low_t* input,
+                                uint16_t* dest,
+                                int stride,
+                                int bd);
 #define vpx_highbd_iwht4x4_1_add vpx_highbd_iwht4x4_1_add_c
 
-void vpx_highbd_lpf_horizontal_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_16_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_c(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
+void vpx_highbd_lpf_horizontal_16_sse2(uint16_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh,
+                                       int bd);
 #define vpx_highbd_lpf_horizontal_16 vpx_highbd_lpf_horizontal_16_sse2
 
-void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_16_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_16_dual_c(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit,
+                                         const uint8_t* limit,
+                                         const uint8_t* thresh,
+                                         int bd);
+void vpx_highbd_lpf_horizontal_16_dual_sse2(uint16_t* s,
+                                            int pitch,
+                                            const uint8_t* blimit,
+                                            const uint8_t* limit,
+                                            const uint8_t* thresh,
+                                            int bd);
 #define vpx_highbd_lpf_horizontal_16_dual vpx_highbd_lpf_horizontal_16_dual_sse2
 
-void vpx_highbd_lpf_horizontal_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_4_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_4_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
+void vpx_highbd_lpf_horizontal_4_sse2(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit,
+                                      const uint8_t* limit,
+                                      const uint8_t* thresh,
+                                      int bd);
 #define vpx_highbd_lpf_horizontal_4 vpx_highbd_lpf_horizontal_4_sse2
 
-void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_horizontal_4_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_4_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
+void vpx_highbd_lpf_horizontal_4_dual_sse2(uint16_t* s,
+                                           int pitch,
+                                           const uint8_t* blimit0,
+                                           const uint8_t* limit0,
+                                           const uint8_t* thresh0,
+                                           const uint8_t* blimit1,
+                                           const uint8_t* limit1,
+                                           const uint8_t* thresh1,
+                                           int bd);
 #define vpx_highbd_lpf_horizontal_4_dual vpx_highbd_lpf_horizontal_4_dual_sse2
 
-void vpx_highbd_lpf_horizontal_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_horizontal_8_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_horizontal_8_c(uint16_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh,
+                                   int bd);
+void vpx_highbd_lpf_horizontal_8_sse2(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit,
+                                      const uint8_t* limit,
+                                      const uint8_t* thresh,
+                                      int bd);
 #define vpx_highbd_lpf_horizontal_8 vpx_highbd_lpf_horizontal_8_sse2
 
-void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_horizontal_8_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_horizontal_8_dual_c(uint16_t* s,
+                                        int pitch,
+                                        const uint8_t* blimit0,
+                                        const uint8_t* limit0,
+                                        const uint8_t* thresh0,
+                                        const uint8_t* blimit1,
+                                        const uint8_t* limit1,
+                                        const uint8_t* thresh1,
+                                        int bd);
+void vpx_highbd_lpf_horizontal_8_dual_sse2(uint16_t* s,
+                                           int pitch,
+                                           const uint8_t* blimit0,
+                                           const uint8_t* limit0,
+                                           const uint8_t* thresh0,
+                                           const uint8_t* blimit1,
+                                           const uint8_t* limit1,
+                                           const uint8_t* thresh1,
+                                           int bd);
 #define vpx_highbd_lpf_horizontal_8_dual vpx_highbd_lpf_horizontal_8_dual_sse2
 
-void vpx_highbd_lpf_vertical_16_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_16_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_c(uint16_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh,
+                                  int bd);
+void vpx_highbd_lpf_vertical_16_sse2(uint16_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh,
+                                     int bd);
 #define vpx_highbd_lpf_vertical_16 vpx_highbd_lpf_vertical_16_sse2
 
-void vpx_highbd_lpf_vertical_16_dual_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_16_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_16_dual_c(uint16_t* s,
+                                       int pitch,
+                                       const uint8_t* blimit,
+                                       const uint8_t* limit,
+                                       const uint8_t* thresh,
+                                       int bd);
+void vpx_highbd_lpf_vertical_16_dual_sse2(uint16_t* s,
+                                          int pitch,
+                                          const uint8_t* blimit,
+                                          const uint8_t* limit,
+                                          const uint8_t* thresh,
+                                          int bd);
 #define vpx_highbd_lpf_vertical_16_dual vpx_highbd_lpf_vertical_16_dual_sse2
 
-void vpx_highbd_lpf_vertical_4_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_4_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_4_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
+void vpx_highbd_lpf_vertical_4_sse2(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
 #define vpx_highbd_lpf_vertical_4 vpx_highbd_lpf_vertical_4_sse2
 
-void vpx_highbd_lpf_vertical_4_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_vertical_4_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_4_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
+void vpx_highbd_lpf_vertical_4_dual_sse2(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit0,
+                                         const uint8_t* limit0,
+                                         const uint8_t* thresh0,
+                                         const uint8_t* blimit1,
+                                         const uint8_t* limit1,
+                                         const uint8_t* thresh1,
+                                         int bd);
 #define vpx_highbd_lpf_vertical_4_dual vpx_highbd_lpf_vertical_4_dual_sse2
 
-void vpx_highbd_lpf_vertical_8_c(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
-void vpx_highbd_lpf_vertical_8_sse2(uint16_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh, int bd);
+void vpx_highbd_lpf_vertical_8_c(uint16_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit,
+                                 const uint8_t* limit,
+                                 const uint8_t* thresh,
+                                 int bd);
+void vpx_highbd_lpf_vertical_8_sse2(uint16_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit,
+                                    const uint8_t* limit,
+                                    const uint8_t* thresh,
+                                    int bd);
 #define vpx_highbd_lpf_vertical_8 vpx_highbd_lpf_vertical_8_sse2
 
-void vpx_highbd_lpf_vertical_8_dual_c(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
-void vpx_highbd_lpf_vertical_8_dual_sse2(uint16_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1, int bd);
+void vpx_highbd_lpf_vertical_8_dual_c(uint16_t* s,
+                                      int pitch,
+                                      const uint8_t* blimit0,
+                                      const uint8_t* limit0,
+                                      const uint8_t* thresh0,
+                                      const uint8_t* blimit1,
+                                      const uint8_t* limit1,
+                                      const uint8_t* thresh1,
+                                      int bd);
+void vpx_highbd_lpf_vertical_8_dual_sse2(uint16_t* s,
+                                         int pitch,
+                                         const uint8_t* blimit0,
+                                         const uint8_t* limit0,
+                                         const uint8_t* thresh0,
+                                         const uint8_t* blimit1,
+                                         const uint8_t* limit1,
+                                         const uint8_t* thresh1,
+                                         int bd);
 #define vpx_highbd_lpf_vertical_8_dual vpx_highbd_lpf_vertical_8_dual_sse2
 
-void vpx_highbd_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_highbd_minmax_8x8_c(const uint8_t* s,
+                             int p,
+                             const uint8_t* d,
+                             int dp,
+                             int* min,
+                             int* max);
 #define vpx_highbd_minmax_8x8 vpx_highbd_minmax_8x8_c
 
-void vpx_highbd_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_highbd_quantize_b_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_c(const tran_low_t* coeff_ptr,
+                             intptr_t n_coeffs,
+                             int skip_block,
+                             const int16_t* zbin_ptr,
+                             const int16_t* round_ptr,
+                             const int16_t* quant_ptr,
+                             const int16_t* quant_shift_ptr,
+                             tran_low_t* qcoeff_ptr,
+                             tran_low_t* dqcoeff_ptr,
+                             const int16_t* dequant_ptr,
+                             uint16_t* eob_ptr,
+                             const int16_t* scan,
+                             const int16_t* iscan);
+void vpx_highbd_quantize_b_sse2(const tran_low_t* coeff_ptr,
+                                intptr_t n_coeffs,
+                                int skip_block,
+                                const int16_t* zbin_ptr,
+                                const int16_t* round_ptr,
+                                const int16_t* quant_ptr,
+                                const int16_t* quant_shift_ptr,
+                                tran_low_t* qcoeff_ptr,
+                                tran_low_t* dqcoeff_ptr,
+                                const int16_t* dequant_ptr,
+                                uint16_t* eob_ptr,
+                                const int16_t* scan,
+                                const int16_t* iscan);
 #define vpx_highbd_quantize_b vpx_highbd_quantize_b_sse2
 
-void vpx_highbd_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_highbd_quantize_b_32x32_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_highbd_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
+void vpx_highbd_quantize_b_32x32_sse2(const tran_low_t* coeff_ptr,
+                                      intptr_t n_coeffs,
+                                      int skip_block,
+                                      const int16_t* zbin_ptr,
+                                      const int16_t* round_ptr,
+                                      const int16_t* quant_ptr,
+                                      const int16_t* quant_shift_ptr,
+                                      tran_low_t* qcoeff_ptr,
+                                      tran_low_t* dqcoeff_ptr,
+                                      const int16_t* dequant_ptr,
+                                      uint16_t* eob_ptr,
+                                      const int16_t* scan,
+                                      const int16_t* iscan);
 #define vpx_highbd_quantize_b_32x32 vpx_highbd_quantize_b_32x32_sse2
 
-unsigned int vpx_highbd_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad16x16_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad16x16 vpx_highbd_sad16x16_sse2
 
-unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x16_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad16x16_avg vpx_highbd_sad16x16_avg_sse2
 
-void vpx_highbd_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad16x16x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad16x16x4d vpx_highbd_sad16x16x4d_sse2
 
-unsigned int vpx_highbd_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad16x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad16x32 vpx_highbd_sad16x32_sse2
 
-unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad16x32_avg vpx_highbd_sad16x32_avg_sse2
 
-void vpx_highbd_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad16x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad16x32x4d vpx_highbd_sad16x32x4d_sse2
 
-unsigned int vpx_highbd_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad16x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad16x8_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int vpx_highbd_sad16x8_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
 #define vpx_highbd_sad16x8 vpx_highbd_sad16x8_sse2
 
-unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad16x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad16x8_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
+unsigned int vpx_highbd_sad16x8_avg_sse2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         const uint8_t* second_pred);
 #define vpx_highbd_sad16x8_avg vpx_highbd_sad16x8_avg_sse2
 
-void vpx_highbd_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad16x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad16x8x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void vpx_highbd_sad16x8x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
 #define vpx_highbd_sad16x8x4d vpx_highbd_sad16x8x4d_sse2
 
-unsigned int vpx_highbd_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x16_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x16_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad32x16 vpx_highbd_sad32x16_sse2
 
-unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x16_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x16_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad32x16_avg vpx_highbd_sad32x16_avg_sse2
 
-void vpx_highbd_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x16x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x16x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad32x16x4d vpx_highbd_sad32x16x4d_sse2
 
-unsigned int vpx_highbd_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad32x32 vpx_highbd_sad32x32_sse2
 
-unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad32x32_avg vpx_highbd_sad32x32_avg_sse2
 
-void vpx_highbd_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad32x32x4d vpx_highbd_sad32x32x4d_sse2
 
-unsigned int vpx_highbd_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad32x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad32x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad32x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad32x64 vpx_highbd_sad32x64_sse2
 
-unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad32x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad32x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad32x64_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad32x64_avg vpx_highbd_sad32x64_avg_sse2
 
-void vpx_highbd_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad32x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad32x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad32x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad32x64x4d vpx_highbd_sad32x64x4d_sse2
 
-unsigned int vpx_highbd_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x4 vpx_highbd_sad4x4_c
 
-unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x4_avg vpx_highbd_sad4x4_avg_c
 
-void vpx_highbd_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad4x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad4x4x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
 #define vpx_highbd_sad4x4x4d vpx_highbd_sad4x4x4d_sse2
 
-unsigned int vpx_highbd_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad4x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
 #define vpx_highbd_sad4x8 vpx_highbd_sad4x8_c
 
-unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad4x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
 #define vpx_highbd_sad4x8_avg vpx_highbd_sad4x8_avg_c
 
-void vpx_highbd_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad4x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad4x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad4x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
 #define vpx_highbd_sad4x8x4d vpx_highbd_sad4x8x4d_sse2
 
-unsigned int vpx_highbd_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad64x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x32_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad64x32_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad64x32 vpx_highbd_sad64x32_sse2
 
-unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad64x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x32_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad64x32_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad64x32_avg vpx_highbd_sad64x32_avg_sse2
 
-void vpx_highbd_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad64x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x32x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad64x32x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad64x32x4d vpx_highbd_sad64x32x4d_sse2
 
-unsigned int vpx_highbd_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad64x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad64x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int vpx_highbd_sad64x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
 #define vpx_highbd_sad64x64 vpx_highbd_sad64x64_sse2
 
-unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad64x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad64x64_avg_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       const uint8_t* second_pred);
+unsigned int vpx_highbd_sad64x64_avg_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          const uint8_t* second_pred);
 #define vpx_highbd_sad64x64_avg vpx_highbd_sad64x64_avg_sse2
 
-void vpx_highbd_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad64x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad64x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void vpx_highbd_sad64x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 #define vpx_highbd_sad64x64x4d vpx_highbd_sad64x64x4d_sse2
 
-unsigned int vpx_highbd_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int vpx_highbd_sad8x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
 #define vpx_highbd_sad8x16 vpx_highbd_sad8x16_sse2
 
-unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x16_avg_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x16_avg_sse2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         const uint8_t* second_pred);
 #define vpx_highbd_sad8x16_avg vpx_highbd_sad8x16_avg_sse2
 
-void vpx_highbd_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void vpx_highbd_sad8x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
 #define vpx_highbd_sad8x16x4d vpx_highbd_sad8x16x4d_sse2
 
-unsigned int vpx_highbd_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int vpx_highbd_sad8x4_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
 #define vpx_highbd_sad8x4 vpx_highbd_sad8x4_sse2
 
-unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x4_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x4_avg_sse2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        const uint8_t* second_pred);
 #define vpx_highbd_sad8x4_avg vpx_highbd_sad8x4_avg_sse2
 
-void vpx_highbd_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad8x4x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
 #define vpx_highbd_sad8x4x4d vpx_highbd_sad8x4x4d_sse2
 
-unsigned int vpx_highbd_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_highbd_sad8x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_highbd_sad8x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int vpx_highbd_sad8x8_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
 #define vpx_highbd_sad8x8 vpx_highbd_sad8x8_sse2
 
-unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_highbd_sad8x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_highbd_sad8x8_avg_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     const uint8_t* second_pred);
+unsigned int vpx_highbd_sad8x8_avg_sse2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        const uint8_t* second_pred);
 #define vpx_highbd_sad8x8_avg vpx_highbd_sad8x8_avg_sse2
 
-void vpx_highbd_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_highbd_sad8x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t* const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_highbd_sad8x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void vpx_highbd_sad8x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
 #define vpx_highbd_sad8x8x4d vpx_highbd_sad8x8x4d_sse2
 
-void vpx_highbd_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride, int bd);
+void vpx_highbd_subtract_block_c(int rows,
+                                 int cols,
+                                 int16_t* diff_ptr,
+                                 ptrdiff_t diff_stride,
+                                 const uint8_t* src_ptr,
+                                 ptrdiff_t src_stride,
+                                 const uint8_t* pred_ptr,
+                                 ptrdiff_t pred_stride,
+                                 int bd);
 #define vpx_highbd_subtract_block vpx_highbd_subtract_block_c
 
-void vpx_highbd_tm_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_16x16_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_tm_predictor_16x16_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_tm_predictor_16x16 vpx_highbd_tm_predictor_16x16_sse2
 
-void vpx_highbd_tm_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_32x32_c(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
+void vpx_highbd_tm_predictor_32x32_sse2(uint16_t* dst,
+                                        ptrdiff_t y_stride,
+                                        const uint16_t* above,
+                                        const uint16_t* left,
+                                        int bd);
 #define vpx_highbd_tm_predictor_32x32 vpx_highbd_tm_predictor_32x32_sse2
 
-void vpx_highbd_tm_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_4x4_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_tm_predictor_4x4_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_tm_predictor_4x4 vpx_highbd_tm_predictor_4x4_sse2
 
-void vpx_highbd_tm_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_tm_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_tm_predictor_8x8_c(uint16_t* dst,
+                                   ptrdiff_t y_stride,
+                                   const uint16_t* above,
+                                   const uint16_t* left,
+                                   int bd);
+void vpx_highbd_tm_predictor_8x8_sse2(uint16_t* dst,
+                                      ptrdiff_t y_stride,
+                                      const uint16_t* above,
+                                      const uint16_t* left,
+                                      int bd);
 #define vpx_highbd_tm_predictor_8x8 vpx_highbd_tm_predictor_8x8_sse2
 
-void vpx_highbd_v_predictor_16x16_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_16x16_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_16x16_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
+void vpx_highbd_v_predictor_16x16_sse2(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_v_predictor_16x16 vpx_highbd_v_predictor_16x16_sse2
 
-void vpx_highbd_v_predictor_32x32_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_32x32_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_32x32_c(uint16_t* dst,
+                                    ptrdiff_t y_stride,
+                                    const uint16_t* above,
+                                    const uint16_t* left,
+                                    int bd);
+void vpx_highbd_v_predictor_32x32_sse2(uint16_t* dst,
+                                       ptrdiff_t y_stride,
+                                       const uint16_t* above,
+                                       const uint16_t* left,
+                                       int bd);
 #define vpx_highbd_v_predictor_32x32 vpx_highbd_v_predictor_32x32_sse2
 
-void vpx_highbd_v_predictor_4x4_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_4x4_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_4x4_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
+void vpx_highbd_v_predictor_4x4_sse2(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_v_predictor_4x4 vpx_highbd_v_predictor_4x4_sse2
 
-void vpx_highbd_v_predictor_8x8_c(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
-void vpx_highbd_v_predictor_8x8_sse2(uint16_t *dst, ptrdiff_t y_stride, const uint16_t *above, const uint16_t *left, int bd);
+void vpx_highbd_v_predictor_8x8_c(uint16_t* dst,
+                                  ptrdiff_t y_stride,
+                                  const uint16_t* above,
+                                  const uint16_t* left,
+                                  int bd);
+void vpx_highbd_v_predictor_8x8_sse2(uint16_t* dst,
+                                     ptrdiff_t y_stride,
+                                     const uint16_t* above,
+                                     const uint16_t* left,
+                                     int bd);
 #define vpx_highbd_v_predictor_8x8 vpx_highbd_v_predictor_8x8_sse2
 
-void vpx_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_10_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_10_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_10_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct16x16_10_add vpx_idct16x16_10_add_sse2
 
-void vpx_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_1_add_sse2(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct16x16_1_add vpx_idct16x16_1_add_sse2
 
-void vpx_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_256_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_256_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct16x16_256_add_sse2(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
 #define vpx_idct16x16_256_add vpx_idct16x16_256_add_sse2
 
-void vpx_idct16x16_38_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct16x16_38_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct16x16_38_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct16x16_38_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
 #define vpx_idct16x16_38_add vpx_idct16x16_38_add_sse2
 
-void vpx_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1024_add_c(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+void vpx_idct32x32_1024_add_sse2(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
 #define vpx_idct32x32_1024_add vpx_idct32x32_1024_add_sse2
 
-void vpx_idct32x32_135_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1024_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_135_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_135_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_135_add_c(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct32x32_1024_add_sse2(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+void vpx_idct32x32_135_add_ssse3(const tran_low_t* input,
+                                 uint8_t* dest,
+                                 int stride);
+RTCD_EXTERN void (*vpx_idct32x32_135_add)(const tran_low_t* input,
+                                          uint8_t* dest,
+                                          int stride);
 
-void vpx_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_1_add_sse2(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
 #define vpx_idct32x32_1_add vpx_idct32x32_1_add_sse2
 
-void vpx_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct32x32_34_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct32x32_34_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct32x32_34_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct32x32_34_add_sse2(const tran_low_t* input,
+                               uint8_t* dest,
+                               int stride);
+void vpx_idct32x32_34_add_ssse3(const tran_low_t* input,
+                                uint8_t* dest,
+                                int stride);
+RTCD_EXTERN void (*vpx_idct32x32_34_add)(const tran_low_t* input,
+                                         uint8_t* dest,
+                                         int stride);
 
-void vpx_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_16_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct4x4_16_add vpx_idct4x4_16_add_sse2
 
-void vpx_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct4x4_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct4x4_1_add_sse2(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct4x4_1_add vpx_idct4x4_1_add_sse2
 
-void vpx_idct8x8_12_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_12_add_ssse3(const tran_low_t *input, uint8_t *dest, int stride);
-RTCD_EXTERN void (*vpx_idct8x8_12_add)(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_12_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_12_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
+void vpx_idct8x8_12_add_ssse3(const tran_low_t* input,
+                              uint8_t* dest,
+                              int stride);
+RTCD_EXTERN void (*vpx_idct8x8_12_add)(const tran_low_t* input,
+                                       uint8_t* dest,
+                                       int stride);
 
-void vpx_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_1_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_1_add_sse2(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_idct8x8_1_add vpx_idct8x8_1_add_sse2
 
-void vpx_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_idct8x8_64_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_idct8x8_64_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_idct8x8_64_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_idct8x8_64_add vpx_idct8x8_64_add_sse2
 
-int16_t vpx_int_pro_col_c(const uint8_t *ref, const int width);
-int16_t vpx_int_pro_col_sse2(const uint8_t *ref, const int width);
+int16_t vpx_int_pro_col_c(const uint8_t* ref, const int width);
+int16_t vpx_int_pro_col_sse2(const uint8_t* ref, const int width);
 #define vpx_int_pro_col vpx_int_pro_col_sse2
 
-void vpx_int_pro_row_c(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
-void vpx_int_pro_row_sse2(int16_t *hbuf, const uint8_t *ref, const int ref_stride, const int height);
+void vpx_int_pro_row_c(int16_t* hbuf,
+                       const uint8_t* ref,
+                       const int ref_stride,
+                       const int height);
+void vpx_int_pro_row_sse2(int16_t* hbuf,
+                          const uint8_t* ref,
+                          const int ref_stride,
+                          const int height);
 #define vpx_int_pro_row vpx_int_pro_row_sse2
 
-void vpx_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest, int stride);
-void vpx_iwht4x4_16_add_sse2(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_16_add_c(const tran_low_t* input, uint8_t* dest, int stride);
+void vpx_iwht4x4_16_add_sse2(const tran_low_t* input,
+                             uint8_t* dest,
+                             int stride);
 #define vpx_iwht4x4_16_add vpx_iwht4x4_16_add_sse2
 
-void vpx_iwht4x4_1_add_c(const tran_low_t *input, uint8_t *dest, int stride);
+void vpx_iwht4x4_1_add_c(const tran_low_t* input, uint8_t* dest, int stride);
 #define vpx_iwht4x4_1_add vpx_iwht4x4_1_add_c
 
-void vpx_lpf_horizontal_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_avx2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_16)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_c(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
+void vpx_lpf_horizontal_16_sse2(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_horizontal_16_avx2(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_16)(uint8_t* s,
+                                          int pitch,
+                                          const uint8_t* blimit,
+                                          const uint8_t* limit,
+                                          const uint8_t* thresh);
 
-void vpx_lpf_horizontal_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_16_dual_avx2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-RTCD_EXTERN void (*vpx_lpf_horizontal_16_dual)(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_16_dual_c(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit,
+                                  const uint8_t* limit,
+                                  const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_sse2(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
+void vpx_lpf_horizontal_16_dual_avx2(uint8_t* s,
+                                     int pitch,
+                                     const uint8_t* blimit,
+                                     const uint8_t* limit,
+                                     const uint8_t* thresh);
+RTCD_EXTERN void (*vpx_lpf_horizontal_16_dual)(uint8_t* s,
+                                               int pitch,
+                                               const uint8_t* blimit,
+                                               const uint8_t* limit,
+                                               const uint8_t* thresh);
 
-void vpx_lpf_horizontal_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_4_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_4_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_4_sse2(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
 #define vpx_lpf_horizontal_4 vpx_lpf_horizontal_4_sse2
 
-void vpx_lpf_horizontal_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_4_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_4_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_4_dual_sse2(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
 #define vpx_lpf_horizontal_4_dual vpx_lpf_horizontal_4_dual_sse2
 
-void vpx_lpf_horizontal_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_horizontal_8_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_horizontal_8_c(uint8_t* s,
+                            int pitch,
+                            const uint8_t* blimit,
+                            const uint8_t* limit,
+                            const uint8_t* thresh);
+void vpx_lpf_horizontal_8_sse2(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit,
+                               const uint8_t* limit,
+                               const uint8_t* thresh);
 #define vpx_lpf_horizontal_8 vpx_lpf_horizontal_8_sse2
 
-void vpx_lpf_horizontal_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_horizontal_8_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_horizontal_8_dual_c(uint8_t* s,
+                                 int pitch,
+                                 const uint8_t* blimit0,
+                                 const uint8_t* limit0,
+                                 const uint8_t* thresh0,
+                                 const uint8_t* blimit1,
+                                 const uint8_t* limit1,
+                                 const uint8_t* thresh1);
+void vpx_lpf_horizontal_8_dual_sse2(uint8_t* s,
+                                    int pitch,
+                                    const uint8_t* blimit0,
+                                    const uint8_t* limit0,
+                                    const uint8_t* thresh0,
+                                    const uint8_t* blimit1,
+                                    const uint8_t* limit1,
+                                    const uint8_t* thresh1);
 #define vpx_lpf_horizontal_8_dual vpx_lpf_horizontal_8_dual_sse2
 
-void vpx_lpf_vertical_16_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_c(uint8_t* s,
+                           int pitch,
+                           const uint8_t* blimit,
+                           const uint8_t* limit,
+                           const uint8_t* thresh);
+void vpx_lpf_vertical_16_sse2(uint8_t* s,
+                              int pitch,
+                              const uint8_t* blimit,
+                              const uint8_t* limit,
+                              const uint8_t* thresh);
 #define vpx_lpf_vertical_16 vpx_lpf_vertical_16_sse2
 
-void vpx_lpf_vertical_16_dual_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_16_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_16_dual_c(uint8_t* s,
+                                int pitch,
+                                const uint8_t* blimit,
+                                const uint8_t* limit,
+                                const uint8_t* thresh);
+void vpx_lpf_vertical_16_dual_sse2(uint8_t* s,
+                                   int pitch,
+                                   const uint8_t* blimit,
+                                   const uint8_t* limit,
+                                   const uint8_t* thresh);
 #define vpx_lpf_vertical_16_dual vpx_lpf_vertical_16_dual_sse2
 
-void vpx_lpf_vertical_4_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_4_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_4_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_4_sse2(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_vertical_4 vpx_lpf_vertical_4_sse2
 
-void vpx_lpf_vertical_4_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_4_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_4_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_4_dual_sse2(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
 #define vpx_lpf_vertical_4_dual vpx_lpf_vertical_4_dual_sse2
 
-void vpx_lpf_vertical_8_c(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
-void vpx_lpf_vertical_8_sse2(uint8_t *s, int pitch, const uint8_t *blimit, const uint8_t *limit, const uint8_t *thresh);
+void vpx_lpf_vertical_8_c(uint8_t* s,
+                          int pitch,
+                          const uint8_t* blimit,
+                          const uint8_t* limit,
+                          const uint8_t* thresh);
+void vpx_lpf_vertical_8_sse2(uint8_t* s,
+                             int pitch,
+                             const uint8_t* blimit,
+                             const uint8_t* limit,
+                             const uint8_t* thresh);
 #define vpx_lpf_vertical_8 vpx_lpf_vertical_8_sse2
 
-void vpx_lpf_vertical_8_dual_c(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
-void vpx_lpf_vertical_8_dual_sse2(uint8_t *s, int pitch, const uint8_t *blimit0, const uint8_t *limit0, const uint8_t *thresh0, const uint8_t *blimit1, const uint8_t *limit1, const uint8_t *thresh1);
+void vpx_lpf_vertical_8_dual_c(uint8_t* s,
+                               int pitch,
+                               const uint8_t* blimit0,
+                               const uint8_t* limit0,
+                               const uint8_t* thresh0,
+                               const uint8_t* blimit1,
+                               const uint8_t* limit1,
+                               const uint8_t* thresh1);
+void vpx_lpf_vertical_8_dual_sse2(uint8_t* s,
+                                  int pitch,
+                                  const uint8_t* blimit0,
+                                  const uint8_t* limit0,
+                                  const uint8_t* thresh0,
+                                  const uint8_t* blimit1,
+                                  const uint8_t* limit1,
+                                  const uint8_t* thresh1);
 #define vpx_lpf_vertical_8_dual vpx_lpf_vertical_8_dual_sse2
 
-void vpx_mbpost_proc_across_ip_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_across_ip_sse2(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_across_ip_c(unsigned char* dst,
+                                 int pitch,
+                                 int rows,
+                                 int cols,
+                                 int flimit);
+void vpx_mbpost_proc_across_ip_sse2(unsigned char* dst,
+                                    int pitch,
+                                    int rows,
+                                    int cols,
+                                    int flimit);
 #define vpx_mbpost_proc_across_ip vpx_mbpost_proc_across_ip_sse2
 
-void vpx_mbpost_proc_down_c(unsigned char *dst, int pitch, int rows, int cols,int flimit);
-void vpx_mbpost_proc_down_sse2(unsigned char *dst, int pitch, int rows, int cols,int flimit);
+void vpx_mbpost_proc_down_c(unsigned char* dst,
+                            int pitch,
+                            int rows,
+                            int cols,
+                            int flimit);
+void vpx_mbpost_proc_down_sse2(unsigned char* dst,
+                               int pitch,
+                               int rows,
+                               int cols,
+                               int flimit);
 #define vpx_mbpost_proc_down vpx_mbpost_proc_down_sse2
 
-void vpx_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
-void vpx_minmax_8x8_sse2(const uint8_t *s, int p, const uint8_t *d, int dp, int *min, int *max);
+void vpx_minmax_8x8_c(const uint8_t* s,
+                      int p,
+                      const uint8_t* d,
+                      int dp,
+                      int* min,
+                      int* max);
+void vpx_minmax_8x8_sse2(const uint8_t* s,
+                         int p,
+                         const uint8_t* d,
+                         int dp,
+                         int* min,
+                         int* max);
 #define vpx_minmax_8x8 vpx_minmax_8x8_sse2
 
-unsigned int vpx_mse16x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x16_avx2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_mse16x16)(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x16_c(const uint8_t* src_ptr,
+                            int source_stride,
+                            const uint8_t* ref_ptr,
+                            int recon_stride,
+                            unsigned int* sse);
+unsigned int vpx_mse16x16_sse2(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
+unsigned int vpx_mse16x16_avx2(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int recon_stride,
+                               unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_mse16x16)(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         const uint8_t* ref_ptr,
+                                         int recon_stride,
+                                         unsigned int* sse);
 
-unsigned int vpx_mse16x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse16x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse16x8_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
+unsigned int vpx_mse16x8_sse2(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int recon_stride,
+                              unsigned int* sse);
 #define vpx_mse16x8 vpx_mse16x8_sse2
 
-unsigned int vpx_mse8x16_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse8x16_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x16_c(const uint8_t* src_ptr,
+                           int source_stride,
+                           const uint8_t* ref_ptr,
+                           int recon_stride,
+                           unsigned int* sse);
+unsigned int vpx_mse8x16_sse2(const uint8_t* src_ptr,
+                              int source_stride,
+                              const uint8_t* ref_ptr,
+                              int recon_stride,
+                              unsigned int* sse);
 #define vpx_mse8x16 vpx_mse8x16_sse2
 
-unsigned int vpx_mse8x8_c(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
-unsigned int vpx_mse8x8_sse2(const uint8_t *src_ptr, int  source_stride, const uint8_t *ref_ptr, int  recon_stride, unsigned int *sse);
+unsigned int vpx_mse8x8_c(const uint8_t* src_ptr,
+                          int source_stride,
+                          const uint8_t* ref_ptr,
+                          int recon_stride,
+                          unsigned int* sse);
+unsigned int vpx_mse8x8_sse2(const uint8_t* src_ptr,
+                             int source_stride,
+                             const uint8_t* ref_ptr,
+                             int recon_stride,
+                             unsigned int* sse);
 #define vpx_mse8x8 vpx_mse8x8_sse2
 
-void vpx_plane_add_noise_c(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
-void vpx_plane_add_noise_sse2(uint8_t *start, const int8_t *noise, int blackclamp, int whiteclamp, int width, int height, int pitch);
+void vpx_plane_add_noise_c(uint8_t* start,
+                           const int8_t* noise,
+                           int blackclamp,
+                           int whiteclamp,
+                           int width,
+                           int height,
+                           int pitch);
+void vpx_plane_add_noise_sse2(uint8_t* start,
+                              const int8_t* noise,
+                              int blackclamp,
+                              int whiteclamp,
+                              int width,
+                              int height,
+                              int pitch);
 #define vpx_plane_add_noise vpx_plane_add_noise_sse2
 
-void vpx_post_proc_down_and_across_mb_row_c(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-void vpx_post_proc_down_and_across_mb_row_sse2(unsigned char *src, unsigned char *dst, int src_pitch, int dst_pitch, int cols, unsigned char *flimits, int size);
-#define vpx_post_proc_down_and_across_mb_row vpx_post_proc_down_and_across_mb_row_sse2
+void vpx_post_proc_down_and_across_mb_row_c(unsigned char* src,
+                                            unsigned char* dst,
+                                            int src_pitch,
+                                            int dst_pitch,
+                                            int cols,
+                                            unsigned char* flimits,
+                                            int size);
+void vpx_post_proc_down_and_across_mb_row_sse2(unsigned char* src,
+                                               unsigned char* dst,
+                                               int src_pitch,
+                                               int dst_pitch,
+                                               int cols,
+                                               unsigned char* flimits,
+                                               int size);
+#define vpx_post_proc_down_and_across_mb_row \
+  vpx_post_proc_down_and_across_mb_row_sse2
 
-void vpx_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_sse2(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_ssse3(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_avx(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_quantize_b)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_c(const tran_low_t* coeff_ptr,
+                      intptr_t n_coeffs,
+                      int skip_block,
+                      const int16_t* zbin_ptr,
+                      const int16_t* round_ptr,
+                      const int16_t* quant_ptr,
+                      const int16_t* quant_shift_ptr,
+                      tran_low_t* qcoeff_ptr,
+                      tran_low_t* dqcoeff_ptr,
+                      const int16_t* dequant_ptr,
+                      uint16_t* eob_ptr,
+                      const int16_t* scan,
+                      const int16_t* iscan);
+void vpx_quantize_b_sse2(const tran_low_t* coeff_ptr,
+                         intptr_t n_coeffs,
+                         int skip_block,
+                         const int16_t* zbin_ptr,
+                         const int16_t* round_ptr,
+                         const int16_t* quant_ptr,
+                         const int16_t* quant_shift_ptr,
+                         tran_low_t* qcoeff_ptr,
+                         tran_low_t* dqcoeff_ptr,
+                         const int16_t* dequant_ptr,
+                         uint16_t* eob_ptr,
+                         const int16_t* scan,
+                         const int16_t* iscan);
+void vpx_quantize_b_ssse3(const tran_low_t* coeff_ptr,
+                          intptr_t n_coeffs,
+                          int skip_block,
+                          const int16_t* zbin_ptr,
+                          const int16_t* round_ptr,
+                          const int16_t* quant_ptr,
+                          const int16_t* quant_shift_ptr,
+                          tran_low_t* qcoeff_ptr,
+                          tran_low_t* dqcoeff_ptr,
+                          const int16_t* dequant_ptr,
+                          uint16_t* eob_ptr,
+                          const int16_t* scan,
+                          const int16_t* iscan);
+void vpx_quantize_b_avx(const tran_low_t* coeff_ptr,
+                        intptr_t n_coeffs,
+                        int skip_block,
+                        const int16_t* zbin_ptr,
+                        const int16_t* round_ptr,
+                        const int16_t* quant_ptr,
+                        const int16_t* quant_shift_ptr,
+                        tran_low_t* qcoeff_ptr,
+                        tran_low_t* dqcoeff_ptr,
+                        const int16_t* dequant_ptr,
+                        uint16_t* eob_ptr,
+                        const int16_t* scan,
+                        const int16_t* iscan);
+RTCD_EXTERN void (*vpx_quantize_b)(const tran_low_t* coeff_ptr,
+                                   intptr_t n_coeffs,
+                                   int skip_block,
+                                   const int16_t* zbin_ptr,
+                                   const int16_t* round_ptr,
+                                   const int16_t* quant_ptr,
+                                   const int16_t* quant_shift_ptr,
+                                   tran_low_t* qcoeff_ptr,
+                                   tran_low_t* dqcoeff_ptr,
+                                   const int16_t* dequant_ptr,
+                                   uint16_t* eob_ptr,
+                                   const int16_t* scan,
+                                   const int16_t* iscan);
 
-void vpx_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_32x32_ssse3(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-void vpx_quantize_b_32x32_avx(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
-RTCD_EXTERN void (*vpx_quantize_b_32x32)(const tran_low_t *coeff_ptr, intptr_t n_coeffs, int skip_block, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan);
+void vpx_quantize_b_32x32_c(const tran_low_t* coeff_ptr,
+                            intptr_t n_coeffs,
+                            int skip_block,
+                            const int16_t* zbin_ptr,
+                            const int16_t* round_ptr,
+                            const int16_t* quant_ptr,
+                            const int16_t* quant_shift_ptr,
+                            tran_low_t* qcoeff_ptr,
+                            tran_low_t* dqcoeff_ptr,
+                            const int16_t* dequant_ptr,
+                            uint16_t* eob_ptr,
+                            const int16_t* scan,
+                            const int16_t* iscan);
+void vpx_quantize_b_32x32_ssse3(const tran_low_t* coeff_ptr,
+                                intptr_t n_coeffs,
+                                int skip_block,
+                                const int16_t* zbin_ptr,
+                                const int16_t* round_ptr,
+                                const int16_t* quant_ptr,
+                                const int16_t* quant_shift_ptr,
+                                tran_low_t* qcoeff_ptr,
+                                tran_low_t* dqcoeff_ptr,
+                                const int16_t* dequant_ptr,
+                                uint16_t* eob_ptr,
+                                const int16_t* scan,
+                                const int16_t* iscan);
+void vpx_quantize_b_32x32_avx(const tran_low_t* coeff_ptr,
+                              intptr_t n_coeffs,
+                              int skip_block,
+                              const int16_t* zbin_ptr,
+                              const int16_t* round_ptr,
+                              const int16_t* quant_ptr,
+                              const int16_t* quant_shift_ptr,
+                              tran_low_t* qcoeff_ptr,
+                              tran_low_t* dqcoeff_ptr,
+                              const int16_t* dequant_ptr,
+                              uint16_t* eob_ptr,
+                              const int16_t* scan,
+                              const int16_t* iscan);
+RTCD_EXTERN void (*vpx_quantize_b_32x32)(const tran_low_t* coeff_ptr,
+                                         intptr_t n_coeffs,
+                                         int skip_block,
+                                         const int16_t* zbin_ptr,
+                                         const int16_t* round_ptr,
+                                         const int16_t* quant_ptr,
+                                         const int16_t* quant_shift_ptr,
+                                         tran_low_t* qcoeff_ptr,
+                                         tran_low_t* dqcoeff_ptr,
+                                         const int16_t* dequant_ptr,
+                                         uint16_t* eob_ptr,
+                                         const int16_t* scan,
+                                         const int16_t* iscan);
 
-unsigned int vpx_sad16x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x16_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad16x16 vpx_sad16x16_sse2
 
-unsigned int vpx_sad16x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x16_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad16x16_avg vpx_sad16x16_avg_sse2
 
-void vpx_sad16x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x3_ssse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x3_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x16x3_sse3(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+void vpx_sad16x16x3_ssse3(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x3)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-void vpx_sad16x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x16x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad16x16x4d vpx_sad16x16x4d_sse2
 
-void vpx_sad16x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x16x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x16x8_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* ref_ptr,
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x16x8_sse4_1(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride,
+                           uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x16x8)(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   uint32_t* sad_array);
 
-unsigned int vpx_sad16x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad16x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
 #define vpx_sad16x32 vpx_sad16x32_sse2
 
-unsigned int vpx_sad16x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad16x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
 #define vpx_sad16x32_avg vpx_sad16x32_avg_sse2
 
-void vpx_sad16x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad16x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad16x32x4d vpx_sad16x32x4d_sse2
 
-unsigned int vpx_sad16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad16x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad16x8_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad16x8_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
 #define vpx_sad16x8 vpx_sad16x8_sse2
 
-unsigned int vpx_sad16x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad16x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad16x8_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad16x8_avg_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
 #define vpx_sad16x8_avg vpx_sad16x8_avg_sse2
 
-void vpx_sad16x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x3_ssse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad16x8x3_sse3(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        uint32_t* sad_array);
+void vpx_sad16x8x3_ssse3(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x3)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad16x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad16x8x4d_sse2(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
 #define vpx_sad16x8x4d vpx_sad16x8x4d_sse2
 
-void vpx_sad16x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad16x8x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad16x8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad16x8x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad16x8x8_sse4_1(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad16x8x8)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad32x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x16_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x16)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x16_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x16_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x16_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x16)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x16_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x16_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x16_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x16_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x16_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x16x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x16x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x16x4d vpx_sad32x16x4d_sse2
 
-unsigned int vpx_sad32x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x32_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x32_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x32_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x32_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x32x4d_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad32x32x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+void vpx_sad32x32x4d_avx2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad32x32x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad32x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad32x64_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad32x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad32x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad32x64_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad32x64_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad32x64)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad32x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad32x64_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad32x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad32x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad32x64_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad32x64_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad32x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad32x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad32x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad32x64x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad32x64x4d vpx_sad32x64x4d_sse2
 
-unsigned int vpx_sad4x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x4_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad4x4 vpx_sad4x4_sse2
 
-unsigned int vpx_sad4x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x4_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad4x4_avg vpx_sad4x4_avg_sse2
 
-void vpx_sad4x4x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad4x4x3_sse3(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x3)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-void vpx_sad4x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x4x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad4x4x4d vpx_sad4x4x4d_sse2
 
-void vpx_sad4x4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad4x4x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad4x4x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad4x4x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad4x4x8_sse4_1(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad4x4x8)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-unsigned int vpx_sad4x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad4x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad4x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad4x8_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad4x8 vpx_sad4x8_sse2
 
-unsigned int vpx_sad4x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad4x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad4x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad4x8_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad4x8_avg vpx_sad4x8_avg_sse2
 
-void vpx_sad4x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad4x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad4x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad4x8x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad4x8x4d vpx_sad4x8x4d_sse2
 
-unsigned int vpx_sad64x32_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x32_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad64x32)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x32_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x32_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad64x32_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad64x32)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad64x32_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x32_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad64x32_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x32_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad64x32_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad64x32_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad64x32x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x32x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x32x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x32x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
 #define vpx_sad64x32x4d vpx_sad64x32x4d_sse2
 
-unsigned int vpx_sad64x64_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad64x64_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-RTCD_EXTERN unsigned int (*vpx_sad64x64)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad64x64_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* ref_ptr,
+                            int ref_stride);
+unsigned int vpx_sad64x64_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+unsigned int vpx_sad64x64_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride);
+RTCD_EXTERN unsigned int (*vpx_sad64x64)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
 
-unsigned int vpx_sad64x64_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad64x64_avg_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-RTCD_EXTERN unsigned int (*vpx_sad64x64_avg)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad64x64_avg_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+unsigned int vpx_sad64x64_avg_avx2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   const uint8_t* second_pred);
+RTCD_EXTERN unsigned int (*vpx_sad64x64_avg)(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             const uint8_t* second_pred);
 
-void vpx_sad64x64x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad64x64x4d_avx2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad64x64x4d)(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad64x64x4d_c(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* const ref_ptr[],
+                       int ref_stride,
+                       uint32_t* sad_array);
+void vpx_sad64x64x4d_sse2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+void vpx_sad64x64x4d_avx2(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* const ref_ptr[],
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad64x64x4d)(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
 
-unsigned int vpx_sad8x16_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x16_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x16_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* ref_ptr,
+                           int ref_stride);
+unsigned int vpx_sad8x16_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride);
 #define vpx_sad8x16 vpx_sad8x16_sse2
 
-unsigned int vpx_sad8x16_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x16_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x16_avg_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               const uint8_t* second_pred);
+unsigned int vpx_sad8x16_avg_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  const uint8_t* second_pred);
 #define vpx_sad8x16_avg vpx_sad8x16_avg_sse2
 
-void vpx_sad8x16x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x3_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x16x3_sse3(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* ref_ptr,
+                        int ref_stride,
+                        uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x3)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-void vpx_sad8x16x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x4d_c(const uint8_t* src_ptr,
+                      int src_stride,
+                      const uint8_t* const ref_ptr[],
+                      int ref_stride,
+                      uint32_t* sad_array);
+void vpx_sad8x16x4d_sse2(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* const ref_ptr[],
+                         int ref_stride,
+                         uint32_t* sad_array);
 #define vpx_sad8x16x4d vpx_sad8x16x4d_sse2
 
-void vpx_sad8x16x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x16x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x16x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x16x8_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* ref_ptr,
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x16x8_sse4_1(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride,
+                          uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x16x8)(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  uint32_t* sad_array);
 
-unsigned int vpx_sad8x4_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x4_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x4_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x4_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad8x4 vpx_sad8x4_sse2
 
-unsigned int vpx_sad8x4_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x4_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x4_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x4_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad8x4_avg vpx_sad8x4_avg_sse2
 
-void vpx_sad8x4x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x4x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x4x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x4x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad8x4x4d vpx_sad8x4x4d_sse2
 
-unsigned int vpx_sad8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
-unsigned int vpx_sad8x8_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride);
+unsigned int vpx_sad8x8_c(const uint8_t* src_ptr,
+                          int src_stride,
+                          const uint8_t* ref_ptr,
+                          int ref_stride);
+unsigned int vpx_sad8x8_sse2(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* ref_ptr,
+                             int ref_stride);
 #define vpx_sad8x8 vpx_sad8x8_sse2
 
-unsigned int vpx_sad8x8_avg_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
-unsigned int vpx_sad8x8_avg_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, const uint8_t *second_pred);
+unsigned int vpx_sad8x8_avg_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* ref_ptr,
+                              int ref_stride,
+                              const uint8_t* second_pred);
+unsigned int vpx_sad8x8_avg_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 const uint8_t* second_pred);
 #define vpx_sad8x8_avg vpx_sad8x8_avg_sse2
 
-void vpx_sad8x8x3_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x3_sse3(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x3)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x3_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad8x8x3_sse3(const uint8_t* src_ptr,
+                       int src_stride,
+                       const uint8_t* ref_ptr,
+                       int ref_stride,
+                       uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x3)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-void vpx_sad8x8x4d_c(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x4d_sse2(const uint8_t *src_ptr, int src_stride, const uint8_t * const ref_ptr[], int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x4d_c(const uint8_t* src_ptr,
+                     int src_stride,
+                     const uint8_t* const ref_ptr[],
+                     int ref_stride,
+                     uint32_t* sad_array);
+void vpx_sad8x8x4d_sse2(const uint8_t* src_ptr,
+                        int src_stride,
+                        const uint8_t* const ref_ptr[],
+                        int ref_stride,
+                        uint32_t* sad_array);
 #define vpx_sad8x8x4d vpx_sad8x8x4d_sse2
 
-void vpx_sad8x8x8_c(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-void vpx_sad8x8x8_sse4_1(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
-RTCD_EXTERN void (*vpx_sad8x8x8)(const uint8_t *src_ptr, int src_stride, const uint8_t *ref_ptr, int ref_stride, uint32_t *sad_array);
+void vpx_sad8x8x8_c(const uint8_t* src_ptr,
+                    int src_stride,
+                    const uint8_t* ref_ptr,
+                    int ref_stride,
+                    uint32_t* sad_array);
+void vpx_sad8x8x8_sse4_1(const uint8_t* src_ptr,
+                         int src_stride,
+                         const uint8_t* ref_ptr,
+                         int ref_stride,
+                         uint32_t* sad_array);
+RTCD_EXTERN void (*vpx_sad8x8x8)(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 uint32_t* sad_array);
 
-int vpx_satd_c(const tran_low_t *coeff, int length);
-int vpx_satd_sse2(const tran_low_t *coeff, int length);
+int vpx_satd_c(const tran_low_t* coeff, int length);
+int vpx_satd_sse2(const tran_low_t* coeff, int length);
 #define vpx_satd vpx_satd_sse2
 
-void vpx_scaled_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-void vpx_scaled_2d_ssse3(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
-RTCD_EXTERN void (*vpx_scaled_2d)(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_2d_c(const uint8_t* src,
+                     ptrdiff_t src_stride,
+                     uint8_t* dst,
+                     ptrdiff_t dst_stride,
+                     const int16_t* filter_x,
+                     int x_step_q4,
+                     const int16_t* filter_y,
+                     int y_step_q4,
+                     int w,
+                     int h);
+void vpx_scaled_2d_ssse3(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
+RTCD_EXTERN void (*vpx_scaled_2d)(const uint8_t* src,
+                                  ptrdiff_t src_stride,
+                                  uint8_t* dst,
+                                  ptrdiff_t dst_stride,
+                                  const int16_t* filter_x,
+                                  int x_step_q4,
+                                  const int16_t* filter_y,
+                                  int y_step_q4,
+                                  int w,
+                                  int h);
 
-void vpx_scaled_avg_2d_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_2d_c(const uint8_t* src,
+                         ptrdiff_t src_stride,
+                         uint8_t* dst,
+                         ptrdiff_t dst_stride,
+                         const int16_t* filter_x,
+                         int x_step_q4,
+                         const int16_t* filter_y,
+                         int y_step_q4,
+                         int w,
+                         int h);
 #define vpx_scaled_avg_2d vpx_scaled_avg_2d_c
 
-void vpx_scaled_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_horiz_c(const uint8_t* src,
+                            ptrdiff_t src_stride,
+                            uint8_t* dst,
+                            ptrdiff_t dst_stride,
+                            const int16_t* filter_x,
+                            int x_step_q4,
+                            const int16_t* filter_y,
+                            int y_step_q4,
+                            int w,
+                            int h);
 #define vpx_scaled_avg_horiz vpx_scaled_avg_horiz_c
 
-void vpx_scaled_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_avg_vert_c(const uint8_t* src,
+                           ptrdiff_t src_stride,
+                           uint8_t* dst,
+                           ptrdiff_t dst_stride,
+                           const int16_t* filter_x,
+                           int x_step_q4,
+                           const int16_t* filter_y,
+                           int y_step_q4,
+                           int w,
+                           int h);
 #define vpx_scaled_avg_vert vpx_scaled_avg_vert_c
 
-void vpx_scaled_horiz_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_horiz_c(const uint8_t* src,
+                        ptrdiff_t src_stride,
+                        uint8_t* dst,
+                        ptrdiff_t dst_stride,
+                        const int16_t* filter_x,
+                        int x_step_q4,
+                        const int16_t* filter_y,
+                        int y_step_q4,
+                        int w,
+                        int h);
 #define vpx_scaled_horiz vpx_scaled_horiz_c
 
-void vpx_scaled_vert_c(const uint8_t *src, ptrdiff_t src_stride, uint8_t *dst, ptrdiff_t dst_stride, const int16_t *filter_x, int x_step_q4, const int16_t *filter_y, int y_step_q4, int w, int h);
+void vpx_scaled_vert_c(const uint8_t* src,
+                       ptrdiff_t src_stride,
+                       uint8_t* dst,
+                       ptrdiff_t dst_stride,
+                       const int16_t* filter_x,
+                       int x_step_q4,
+                       const int16_t* filter_y,
+                       int y_step_q4,
+                       int w,
+                       int h);
 #define vpx_scaled_vert vpx_scaled_vert_c
 
-uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x16_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance16x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance16x8_ssse3(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance16x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x16_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x32_avx2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance32x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance32x64_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance32x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x4_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance4x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance4x8_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance4x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x32_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x32)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_c(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse,
+                                           const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_sse2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_ssse3(const uint8_t* src_ptr,
+                                               int source_stride,
+                                               int xoffset,
+                                               int yoffset,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride,
+                                               uint32_t* sse,
+                                               const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance64x64_avx2(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance64x64)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_c(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse,
+                                          const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_sse2(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x16_ssse3(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              int xoffset,
+                                              int yoffset,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              uint32_t* sse,
+                                              const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x16)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x4_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x4)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-uint32_t vpx_sub_pixel_avg_variance8x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse, const uint8_t *second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_c(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse,
+                                         const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_sse2(const uint8_t* src_ptr,
+                                            int source_stride,
+                                            int xoffset,
+                                            int yoffset,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride,
+                                            uint32_t* sse,
+                                            const uint8_t* second_pred);
+uint32_t vpx_sub_pixel_avg_variance8x8_ssse3(const uint8_t* src_ptr,
+                                             int source_stride,
+                                             int xoffset,
+                                             int yoffset,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride,
+                                             uint32_t* sse,
+                                             const uint8_t* second_pred);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_avg_variance8x8)(
+    const uint8_t* src_ptr,
+    int source_stride,
+    int xoffset,
+    int yoffset,
+    const uint8_t* ref_ptr,
+    int ref_stride,
+    uint32_t* sse,
+    const uint8_t* second_pred);
 
-uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x16_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x16)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance16x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance16x8_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+uint32_t vpx_sub_pixel_variance16x8_ssse3(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance16x8)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x16_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x16_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x16)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x32_avx2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance32x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance32x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance32x64_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance32x64)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x4_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x4)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance4x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance4x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance4x8_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance4x8)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x32_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x32)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x32_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x32_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x32)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x64)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance64x64_c(const uint8_t* src_ptr,
+                                       int source_stride,
+                                       int xoffset,
+                                       int yoffset,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride,
+                                       uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_sse2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_ssse3(const uint8_t* src_ptr,
+                                           int source_stride,
+                                           int xoffset,
+                                           int yoffset,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride,
+                                           uint32_t* sse);
+uint32_t vpx_sub_pixel_variance64x64_avx2(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance64x64)(const uint8_t* src_ptr,
+                                                    int source_stride,
+                                                    int xoffset,
+                                                    int yoffset,
+                                                    const uint8_t* ref_ptr,
+                                                    int ref_stride,
+                                                    uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x16_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x16)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x16_c(const uint8_t* src_ptr,
+                                      int source_stride,
+                                      int xoffset,
+                                      int yoffset,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride,
+                                      uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_sse2(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x16_ssse3(const uint8_t* src_ptr,
+                                          int source_stride,
+                                          int xoffset,
+                                          int yoffset,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride,
+                                          uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x16)(const uint8_t* src_ptr,
+                                                   int source_stride,
+                                                   int xoffset,
+                                                   int yoffset,
+                                                   const uint8_t* ref_ptr,
+                                                   int ref_stride,
+                                                   uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x4_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x4)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x4_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x4_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x4)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-uint32_t vpx_sub_pixel_variance8x8_ssse3(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
-RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x8)(const uint8_t *src_ptr, int source_stride, int xoffset, int  yoffset, const uint8_t *ref_ptr, int ref_stride, uint32_t *sse);
+uint32_t vpx_sub_pixel_variance8x8_c(const uint8_t* src_ptr,
+                                     int source_stride,
+                                     int xoffset,
+                                     int yoffset,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride,
+                                     uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_sse2(const uint8_t* src_ptr,
+                                        int source_stride,
+                                        int xoffset,
+                                        int yoffset,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride,
+                                        uint32_t* sse);
+uint32_t vpx_sub_pixel_variance8x8_ssse3(const uint8_t* src_ptr,
+                                         int source_stride,
+                                         int xoffset,
+                                         int yoffset,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride,
+                                         uint32_t* sse);
+RTCD_EXTERN uint32_t (*vpx_sub_pixel_variance8x8)(const uint8_t* src_ptr,
+                                                  int source_stride,
+                                                  int xoffset,
+                                                  int yoffset,
+                                                  const uint8_t* ref_ptr,
+                                                  int ref_stride,
+                                                  uint32_t* sse);
 
-void vpx_subtract_block_c(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
-void vpx_subtract_block_sse2(int rows, int cols, int16_t *diff_ptr, ptrdiff_t diff_stride, const uint8_t *src_ptr, ptrdiff_t src_stride, const uint8_t *pred_ptr, ptrdiff_t pred_stride);
+void vpx_subtract_block_c(int rows,
+                          int cols,
+                          int16_t* diff_ptr,
+                          ptrdiff_t diff_stride,
+                          const uint8_t* src_ptr,
+                          ptrdiff_t src_stride,
+                          const uint8_t* pred_ptr,
+                          ptrdiff_t pred_stride);
+void vpx_subtract_block_sse2(int rows,
+                             int cols,
+                             int16_t* diff_ptr,
+                             ptrdiff_t diff_stride,
+                             const uint8_t* src_ptr,
+                             ptrdiff_t src_stride,
+                             const uint8_t* pred_ptr,
+                             ptrdiff_t pred_stride);
 #define vpx_subtract_block vpx_subtract_block_sse2
 
-uint64_t vpx_sum_squares_2d_i16_c(const int16_t *src, int stride, int size);
-uint64_t vpx_sum_squares_2d_i16_sse2(const int16_t *src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_c(const int16_t* src, int stride, int size);
+uint64_t vpx_sum_squares_2d_i16_sse2(const int16_t* src, int stride, int size);
 #define vpx_sum_squares_2d_i16 vpx_sum_squares_2d_i16_sse2
 
-void vpx_tm_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_16x16_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_16x16_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_tm_predictor_16x16 vpx_tm_predictor_16x16_sse2
 
-void vpx_tm_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_32x32_c(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
+void vpx_tm_predictor_32x32_sse2(uint8_t* dst,
+                                 ptrdiff_t y_stride,
+                                 const uint8_t* above,
+                                 const uint8_t* left);
 #define vpx_tm_predictor_32x32 vpx_tm_predictor_32x32_sse2
 
-void vpx_tm_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_4x4_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_tm_predictor_4x4 vpx_tm_predictor_4x4_sse2
 
-void vpx_tm_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_tm_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_tm_predictor_8x8_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
+void vpx_tm_predictor_8x8_sse2(uint8_t* dst,
+                               ptrdiff_t y_stride,
+                               const uint8_t* above,
+                               const uint8_t* left);
 #define vpx_tm_predictor_8x8 vpx_tm_predictor_8x8_sse2
 
-void vpx_v_predictor_16x16_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_16x16_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_16x16_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_16x16_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_v_predictor_16x16 vpx_v_predictor_16x16_sse2
 
-void vpx_v_predictor_32x32_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_32x32_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_32x32_c(uint8_t* dst,
+                             ptrdiff_t y_stride,
+                             const uint8_t* above,
+                             const uint8_t* left);
+void vpx_v_predictor_32x32_sse2(uint8_t* dst,
+                                ptrdiff_t y_stride,
+                                const uint8_t* above,
+                                const uint8_t* left);
 #define vpx_v_predictor_32x32 vpx_v_predictor_32x32_sse2
 
-void vpx_v_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_4x4_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_4x4_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_4x4_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_v_predictor_4x4 vpx_v_predictor_4x4_sse2
 
-void vpx_v_predictor_8x8_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
-void vpx_v_predictor_8x8_sse2(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_v_predictor_8x8_c(uint8_t* dst,
+                           ptrdiff_t y_stride,
+                           const uint8_t* above,
+                           const uint8_t* left);
+void vpx_v_predictor_8x8_sse2(uint8_t* dst,
+                              ptrdiff_t y_stride,
+                              const uint8_t* above,
+                              const uint8_t* left);
 #define vpx_v_predictor_8x8 vpx_v_predictor_8x8_sse2
 
-unsigned int vpx_variance16x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x16_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance16x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x16_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance16x16_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance16x16)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance16x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance16x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance16x32 vpx_variance16x32_sse2
 
-unsigned int vpx_variance16x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance16x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance16x8_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance16x8_sse2(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
 #define vpx_variance16x8 vpx_variance16x8_sse2
 
-unsigned int vpx_variance32x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x16_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x16)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x16_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x16_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance32x16_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x16)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance32x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x32_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance32x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance32x32_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance32x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance32x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance32x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance32x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance32x64_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
 #define vpx_variance32x64 vpx_variance32x64_sse2
 
-unsigned int vpx_variance4x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x4_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x4_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance4x4 vpx_variance4x4_sse2
 
-unsigned int vpx_variance4x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance4x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance4x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance4x8_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance4x8 vpx_variance4x8_sse2
 
-unsigned int vpx_variance64x32_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x32_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance64x32)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x32_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x32_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance64x32_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance64x32)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance64x64_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance64x64_avx2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-RTCD_EXTERN unsigned int (*vpx_variance64x64)(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance64x64_c(const uint8_t* src_ptr,
+                                 int source_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride,
+                                 unsigned int* sse);
+unsigned int vpx_variance64x64_sse2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+unsigned int vpx_variance64x64_avx2(const uint8_t* src_ptr,
+                                    int source_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride,
+                                    unsigned int* sse);
+RTCD_EXTERN unsigned int (*vpx_variance64x64)(const uint8_t* src_ptr,
+                                              int source_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride,
+                                              unsigned int* sse);
 
-unsigned int vpx_variance8x16_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x16_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x16_c(const uint8_t* src_ptr,
+                                int source_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride,
+                                unsigned int* sse);
+unsigned int vpx_variance8x16_sse2(const uint8_t* src_ptr,
+                                   int source_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride,
+                                   unsigned int* sse);
 #define vpx_variance8x16 vpx_variance8x16_sse2
 
-unsigned int vpx_variance8x4_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x4_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x4_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x4_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance8x4 vpx_variance8x4_sse2
 
-unsigned int vpx_variance8x8_c(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
-unsigned int vpx_variance8x8_sse2(const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, int ref_stride, unsigned int *sse);
+unsigned int vpx_variance8x8_c(const uint8_t* src_ptr,
+                               int source_stride,
+                               const uint8_t* ref_ptr,
+                               int ref_stride,
+                               unsigned int* sse);
+unsigned int vpx_variance8x8_sse2(const uint8_t* src_ptr,
+                                  int source_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride,
+                                  unsigned int* sse);
 #define vpx_variance8x8 vpx_variance8x8_sse2
 
-void vpx_ve_predictor_4x4_c(uint8_t *dst, ptrdiff_t y_stride, const uint8_t *above, const uint8_t *left);
+void vpx_ve_predictor_4x4_c(uint8_t* dst,
+                            ptrdiff_t y_stride,
+                            const uint8_t* above,
+                            const uint8_t* left);
 #define vpx_ve_predictor_4x4 vpx_ve_predictor_4x4_c
 
-int vpx_vector_var_c(const int16_t *ref, const int16_t *src, const int bwl);
-int vpx_vector_var_sse2(const int16_t *ref, const int16_t *src, const int bwl);
+int vpx_vector_var_c(const int16_t* ref, const int16_t* src, const int bwl);
+int vpx_vector_var_sse2(const int16_t* ref, const int16_t* src, const int bwl);
 #define vpx_vector_var vpx_vector_var_sse2
 
 void vpx_dsp_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
+  (void)flags;
 
-    vpx_convolve8 = vpx_convolve8_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8 = vpx_convolve8_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8 = vpx_convolve8_avx2;
-    vpx_convolve8_avg = vpx_convolve8_avg_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg = vpx_convolve8_avg_ssse3;
-    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_ssse3;
-    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_ssse3;
-    vpx_convolve8_horiz = vpx_convolve8_horiz_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_horiz = vpx_convolve8_horiz_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8_horiz = vpx_convolve8_horiz_avx2;
-    vpx_convolve8_vert = vpx_convolve8_vert_sse2;
-    if (flags & HAS_SSSE3) vpx_convolve8_vert = vpx_convolve8_vert_ssse3;
-    if (flags & HAS_AVX2) vpx_convolve8_vert = vpx_convolve8_vert_avx2;
-    vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_ssse3;
-    vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_ssse3;
-    vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_ssse3;
-    vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_ssse3;
-    vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_ssse3;
-    vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_ssse3;
-    vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_ssse3;
-    vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_ssse3;
-    vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_ssse3;
-    vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_ssse3;
-    vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_ssse3;
-    vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_ssse3;
-    vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_c;
-    if (flags & HAS_SSSE3) vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_ssse3;
-    vpx_get16x16var = vpx_get16x16var_sse2;
-    if (flags & HAS_AVX2) vpx_get16x16var = vpx_get16x16var_avx2;
-    vpx_hadamard_8x8 = vpx_hadamard_8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_hadamard_8x8 = vpx_hadamard_8x8_ssse3;
-    vpx_highbd_convolve8 = vpx_highbd_convolve8_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8 = vpx_highbd_convolve8_avx2;
-    vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_avx2;
-    vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_avx2;
-    vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_avx2;
-    vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_avx2;
-    vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_avx2;
-    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_avx2;
-    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_sse2;
-    if (flags & HAS_AVX2) vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_avx2;
-    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse4_1;
-    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse4_1;
-    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse2;
-    if (flags & HAS_SSE4_1) vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse4_1;
-    vpx_idct32x32_135_add = vpx_idct32x32_1024_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct32x32_135_add = vpx_idct32x32_135_add_ssse3;
-    vpx_idct32x32_34_add = vpx_idct32x32_34_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct32x32_34_add = vpx_idct32x32_34_add_ssse3;
-    vpx_idct8x8_12_add = vpx_idct8x8_12_add_sse2;
-    if (flags & HAS_SSSE3) vpx_idct8x8_12_add = vpx_idct8x8_12_add_ssse3;
-    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_sse2;
-    if (flags & HAS_AVX2) vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_avx2;
-    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_sse2;
-    if (flags & HAS_AVX2) vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_avx2;
-    vpx_mse16x16 = vpx_mse16x16_sse2;
-    if (flags & HAS_AVX2) vpx_mse16x16 = vpx_mse16x16_avx2;
-    vpx_quantize_b = vpx_quantize_b_sse2;
-    if (flags & HAS_SSSE3) vpx_quantize_b = vpx_quantize_b_ssse3;
-    if (flags & HAS_AVX) vpx_quantize_b = vpx_quantize_b_avx;
-    vpx_quantize_b_32x32 = vpx_quantize_b_32x32_c;
-    if (flags & HAS_SSSE3) vpx_quantize_b_32x32 = vpx_quantize_b_32x32_ssse3;
-    if (flags & HAS_AVX) vpx_quantize_b_32x32 = vpx_quantize_b_32x32_avx;
-    vpx_sad16x16x3 = vpx_sad16x16x3_c;
-    if (flags & HAS_SSE3) vpx_sad16x16x3 = vpx_sad16x16x3_sse3;
-    if (flags & HAS_SSSE3) vpx_sad16x16x3 = vpx_sad16x16x3_ssse3;
-    vpx_sad16x16x8 = vpx_sad16x16x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad16x16x8 = vpx_sad16x16x8_sse4_1;
-    vpx_sad16x8x3 = vpx_sad16x8x3_c;
-    if (flags & HAS_SSE3) vpx_sad16x8x3 = vpx_sad16x8x3_sse3;
-    if (flags & HAS_SSSE3) vpx_sad16x8x3 = vpx_sad16x8x3_ssse3;
-    vpx_sad16x8x8 = vpx_sad16x8x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad16x8x8 = vpx_sad16x8x8_sse4_1;
-    vpx_sad32x16 = vpx_sad32x16_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x16 = vpx_sad32x16_avx2;
-    vpx_sad32x16_avg = vpx_sad32x16_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x16_avg = vpx_sad32x16_avg_avx2;
-    vpx_sad32x32 = vpx_sad32x32_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32 = vpx_sad32x32_avx2;
-    vpx_sad32x32_avg = vpx_sad32x32_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32_avg = vpx_sad32x32_avg_avx2;
-    vpx_sad32x32x4d = vpx_sad32x32x4d_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x32x4d = vpx_sad32x32x4d_avx2;
-    vpx_sad32x64 = vpx_sad32x64_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x64 = vpx_sad32x64_avx2;
-    vpx_sad32x64_avg = vpx_sad32x64_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad32x64_avg = vpx_sad32x64_avg_avx2;
-    vpx_sad4x4x3 = vpx_sad4x4x3_c;
-    if (flags & HAS_SSE3) vpx_sad4x4x3 = vpx_sad4x4x3_sse3;
-    vpx_sad4x4x8 = vpx_sad4x4x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad4x4x8 = vpx_sad4x4x8_sse4_1;
-    vpx_sad64x32 = vpx_sad64x32_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x32 = vpx_sad64x32_avx2;
-    vpx_sad64x32_avg = vpx_sad64x32_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x32_avg = vpx_sad64x32_avg_avx2;
-    vpx_sad64x64 = vpx_sad64x64_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64 = vpx_sad64x64_avx2;
-    vpx_sad64x64_avg = vpx_sad64x64_avg_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64_avg = vpx_sad64x64_avg_avx2;
-    vpx_sad64x64x4d = vpx_sad64x64x4d_sse2;
-    if (flags & HAS_AVX2) vpx_sad64x64x4d = vpx_sad64x64x4d_avx2;
-    vpx_sad8x16x3 = vpx_sad8x16x3_c;
-    if (flags & HAS_SSE3) vpx_sad8x16x3 = vpx_sad8x16x3_sse3;
-    vpx_sad8x16x8 = vpx_sad8x16x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad8x16x8 = vpx_sad8x16x8_sse4_1;
-    vpx_sad8x8x3 = vpx_sad8x8x3_c;
-    if (flags & HAS_SSE3) vpx_sad8x8x3 = vpx_sad8x8x3_sse3;
-    vpx_sad8x8x8 = vpx_sad8x8x8_c;
-    if (flags & HAS_SSE4_1) vpx_sad8x8x8 = vpx_sad8x8x8_sse4_1;
-    vpx_scaled_2d = vpx_scaled_2d_c;
-    if (flags & HAS_SSSE3) vpx_scaled_2d = vpx_scaled_2d_ssse3;
-    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_ssse3;
-    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_ssse3;
-    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_ssse3;
-    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_ssse3;
-    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_avx2;
-    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_ssse3;
-    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_ssse3;
-    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_ssse3;
-    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_ssse3;
-    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_avx2;
-    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_ssse3;
-    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_ssse3;
-    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_ssse3;
-    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_ssse3;
-    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_ssse3;
-    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_ssse3;
-    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_ssse3;
-    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_avx2;
-    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_ssse3;
-    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_ssse3;
-    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_ssse3;
-    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_ssse3;
-    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_ssse3;
-    if (flags & HAS_AVX2) vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_avx2;
-    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_ssse3;
-    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_ssse3;
-    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_sse2;
-    if (flags & HAS_SSSE3) vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_ssse3;
-    vpx_variance16x16 = vpx_variance16x16_sse2;
-    if (flags & HAS_AVX2) vpx_variance16x16 = vpx_variance16x16_avx2;
-    vpx_variance32x16 = vpx_variance32x16_sse2;
-    if (flags & HAS_AVX2) vpx_variance32x16 = vpx_variance32x16_avx2;
-    vpx_variance32x32 = vpx_variance32x32_sse2;
-    if (flags & HAS_AVX2) vpx_variance32x32 = vpx_variance32x32_avx2;
-    vpx_variance64x32 = vpx_variance64x32_sse2;
-    if (flags & HAS_AVX2) vpx_variance64x32 = vpx_variance64x32_avx2;
-    vpx_variance64x64 = vpx_variance64x64_sse2;
-    if (flags & HAS_AVX2) vpx_variance64x64 = vpx_variance64x64_avx2;
+  vpx_convolve8 = vpx_convolve8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8 = vpx_convolve8_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8 = vpx_convolve8_avx2;
+  vpx_convolve8_avg = vpx_convolve8_avg_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg = vpx_convolve8_avg_ssse3;
+  vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg_horiz = vpx_convolve8_avg_horiz_ssse3;
+  vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_avg_vert = vpx_convolve8_avg_vert_ssse3;
+  vpx_convolve8_horiz = vpx_convolve8_horiz_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8_horiz = vpx_convolve8_horiz_avx2;
+  vpx_convolve8_vert = vpx_convolve8_vert_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_convolve8_vert = vpx_convolve8_vert_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_convolve8_vert = vpx_convolve8_vert_avx2;
+  vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_16x16 = vpx_d153_predictor_16x16_ssse3;
+  vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_32x32 = vpx_d153_predictor_32x32_ssse3;
+  vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_4x4 = vpx_d153_predictor_4x4_ssse3;
+  vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d153_predictor_8x8 = vpx_d153_predictor_8x8_ssse3;
+  vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_16x16 = vpx_d207_predictor_16x16_ssse3;
+  vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_32x32 = vpx_d207_predictor_32x32_ssse3;
+  vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d207_predictor_8x8 = vpx_d207_predictor_8x8_ssse3;
+  vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d45_predictor_16x16 = vpx_d45_predictor_16x16_ssse3;
+  vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d45_predictor_32x32 = vpx_d45_predictor_32x32_ssse3;
+  vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_16x16 = vpx_d63_predictor_16x16_ssse3;
+  vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_32x32 = vpx_d63_predictor_32x32_ssse3;
+  vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_4x4 = vpx_d63_predictor_4x4_ssse3;
+  vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_c;
+  if (flags & HAS_SSSE3)
+    vpx_d63_predictor_8x8 = vpx_d63_predictor_8x8_ssse3;
+  vpx_get16x16var = vpx_get16x16var_sse2;
+  if (flags & HAS_AVX2)
+    vpx_get16x16var = vpx_get16x16var_avx2;
+  vpx_hadamard_8x8 = vpx_hadamard_8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_hadamard_8x8 = vpx_hadamard_8x8_ssse3;
+  vpx_highbd_convolve8 = vpx_highbd_convolve8_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8 = vpx_highbd_convolve8_avx2;
+  vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg = vpx_highbd_convolve8_avg_avx2;
+  vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg_horiz = vpx_highbd_convolve8_avg_horiz_avx2;
+  vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_avg_vert = vpx_highbd_convolve8_avg_vert_avx2;
+  vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_horiz = vpx_highbd_convolve8_horiz_avx2;
+  vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve8_vert = vpx_highbd_convolve8_vert_avx2;
+  vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve_avg = vpx_highbd_convolve_avg_avx2;
+  vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_sse2;
+  if (flags & HAS_AVX2)
+    vpx_highbd_convolve_copy = vpx_highbd_convolve_copy_avx2;
+  vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct4x4_16_add = vpx_highbd_idct4x4_16_add_sse4_1;
+  vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct8x8_12_add = vpx_highbd_idct8x8_12_add_sse4_1;
+  vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse2;
+  if (flags & HAS_SSE4_1)
+    vpx_highbd_idct8x8_64_add = vpx_highbd_idct8x8_64_add_sse4_1;
+  vpx_idct32x32_135_add = vpx_idct32x32_1024_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct32x32_135_add = vpx_idct32x32_135_add_ssse3;
+  vpx_idct32x32_34_add = vpx_idct32x32_34_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct32x32_34_add = vpx_idct32x32_34_add_ssse3;
+  vpx_idct8x8_12_add = vpx_idct8x8_12_add_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_idct8x8_12_add = vpx_idct8x8_12_add_ssse3;
+  vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_lpf_horizontal_16 = vpx_lpf_horizontal_16_avx2;
+  vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_sse2;
+  if (flags & HAS_AVX2)
+    vpx_lpf_horizontal_16_dual = vpx_lpf_horizontal_16_dual_avx2;
+  vpx_mse16x16 = vpx_mse16x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_mse16x16 = vpx_mse16x16_avx2;
+  vpx_quantize_b = vpx_quantize_b_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_quantize_b = vpx_quantize_b_ssse3;
+  if (flags & HAS_AVX)
+    vpx_quantize_b = vpx_quantize_b_avx;
+  vpx_quantize_b_32x32 = vpx_quantize_b_32x32_c;
+  if (flags & HAS_SSSE3)
+    vpx_quantize_b_32x32 = vpx_quantize_b_32x32_ssse3;
+  if (flags & HAS_AVX)
+    vpx_quantize_b_32x32 = vpx_quantize_b_32x32_avx;
+  vpx_sad16x16x3 = vpx_sad16x16x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad16x16x3 = vpx_sad16x16x3_sse3;
+  if (flags & HAS_SSSE3)
+    vpx_sad16x16x3 = vpx_sad16x16x3_ssse3;
+  vpx_sad16x16x8 = vpx_sad16x16x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad16x16x8 = vpx_sad16x16x8_sse4_1;
+  vpx_sad16x8x3 = vpx_sad16x8x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad16x8x3 = vpx_sad16x8x3_sse3;
+  if (flags & HAS_SSSE3)
+    vpx_sad16x8x3 = vpx_sad16x8x3_ssse3;
+  vpx_sad16x8x8 = vpx_sad16x8x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad16x8x8 = vpx_sad16x8x8_sse4_1;
+  vpx_sad32x16 = vpx_sad32x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x16 = vpx_sad32x16_avx2;
+  vpx_sad32x16_avg = vpx_sad32x16_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x16_avg = vpx_sad32x16_avg_avx2;
+  vpx_sad32x32 = vpx_sad32x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32 = vpx_sad32x32_avx2;
+  vpx_sad32x32_avg = vpx_sad32x32_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32_avg = vpx_sad32x32_avg_avx2;
+  vpx_sad32x32x4d = vpx_sad32x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x32x4d = vpx_sad32x32x4d_avx2;
+  vpx_sad32x64 = vpx_sad32x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x64 = vpx_sad32x64_avx2;
+  vpx_sad32x64_avg = vpx_sad32x64_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad32x64_avg = vpx_sad32x64_avg_avx2;
+  vpx_sad4x4x3 = vpx_sad4x4x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad4x4x3 = vpx_sad4x4x3_sse3;
+  vpx_sad4x4x8 = vpx_sad4x4x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad4x4x8 = vpx_sad4x4x8_sse4_1;
+  vpx_sad64x32 = vpx_sad64x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x32 = vpx_sad64x32_avx2;
+  vpx_sad64x32_avg = vpx_sad64x32_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x32_avg = vpx_sad64x32_avg_avx2;
+  vpx_sad64x64 = vpx_sad64x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64 = vpx_sad64x64_avx2;
+  vpx_sad64x64_avg = vpx_sad64x64_avg_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64_avg = vpx_sad64x64_avg_avx2;
+  vpx_sad64x64x4d = vpx_sad64x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    vpx_sad64x64x4d = vpx_sad64x64x4d_avx2;
+  vpx_sad8x16x3 = vpx_sad8x16x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad8x16x3 = vpx_sad8x16x3_sse3;
+  vpx_sad8x16x8 = vpx_sad8x16x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad8x16x8 = vpx_sad8x16x8_sse4_1;
+  vpx_sad8x8x3 = vpx_sad8x8x3_c;
+  if (flags & HAS_SSE3)
+    vpx_sad8x8x3 = vpx_sad8x8x3_sse3;
+  vpx_sad8x8x8 = vpx_sad8x8x8_c;
+  if (flags & HAS_SSE4_1)
+    vpx_sad8x8x8 = vpx_sad8x8x8_sse4_1;
+  vpx_scaled_2d = vpx_scaled_2d_c;
+  if (flags & HAS_SSSE3)
+    vpx_scaled_2d = vpx_scaled_2d_ssse3;
+  vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x16 = vpx_sub_pixel_avg_variance16x16_ssse3;
+  vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x32 = vpx_sub_pixel_avg_variance16x32_ssse3;
+  vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance16x8 = vpx_sub_pixel_avg_variance16x8_ssse3;
+  vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x16 = vpx_sub_pixel_avg_variance32x16_ssse3;
+  vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_avg_variance32x32 = vpx_sub_pixel_avg_variance32x32_avx2;
+  vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance32x64 = vpx_sub_pixel_avg_variance32x64_ssse3;
+  vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance4x4 = vpx_sub_pixel_avg_variance4x4_ssse3;
+  vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance4x8 = vpx_sub_pixel_avg_variance4x8_ssse3;
+  vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance64x32 = vpx_sub_pixel_avg_variance64x32_ssse3;
+  vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_avg_variance64x64 = vpx_sub_pixel_avg_variance64x64_avx2;
+  vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x16 = vpx_sub_pixel_avg_variance8x16_ssse3;
+  vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x4 = vpx_sub_pixel_avg_variance8x4_ssse3;
+  vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_avg_variance8x8 = vpx_sub_pixel_avg_variance8x8_ssse3;
+  vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x16 = vpx_sub_pixel_variance16x16_ssse3;
+  vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x32 = vpx_sub_pixel_variance16x32_ssse3;
+  vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance16x8 = vpx_sub_pixel_variance16x8_ssse3;
+  vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x16 = vpx_sub_pixel_variance32x16_ssse3;
+  vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_variance32x32 = vpx_sub_pixel_variance32x32_avx2;
+  vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance32x64 = vpx_sub_pixel_variance32x64_ssse3;
+  vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance4x4 = vpx_sub_pixel_variance4x4_ssse3;
+  vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance4x8 = vpx_sub_pixel_variance4x8_ssse3;
+  vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance64x32 = vpx_sub_pixel_variance64x32_ssse3;
+  vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_ssse3;
+  if (flags & HAS_AVX2)
+    vpx_sub_pixel_variance64x64 = vpx_sub_pixel_variance64x64_avx2;
+  vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x16 = vpx_sub_pixel_variance8x16_ssse3;
+  vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x4 = vpx_sub_pixel_variance8x4_ssse3;
+  vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_sse2;
+  if (flags & HAS_SSSE3)
+    vpx_sub_pixel_variance8x8 = vpx_sub_pixel_variance8x8_ssse3;
+  vpx_variance16x16 = vpx_variance16x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance16x16 = vpx_variance16x16_avx2;
+  vpx_variance32x16 = vpx_variance32x16_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance32x16 = vpx_variance32x16_avx2;
+  vpx_variance32x32 = vpx_variance32x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance32x32 = vpx_variance32x32_avx2;
+  vpx_variance64x32 = vpx_variance64x32_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance64x32 = vpx_variance64x32_avx2;
+  vpx_variance64x64 = vpx_variance64x64_sse2;
+  if (flags & HAS_AVX2)
+    vpx_variance64x64 = vpx_variance64x64_avx2;
 }
 #endif
 

third_party/libvpx/source/config/win/x64/vpx_scale_rtcd.h

diff --git a/third_party/libvpx/source/config/win/x64/vpx_scale_rtcd.h b/third_party/libvpx/source/config/win/x64/vpx_scale_rtcd.h
index ada0f6d..0ba352cb 100644
--- a/third_party/libvpx/source/config/win/x64/vpx_scale_rtcd.h
+++ b/third_party/libvpx/source/config/win/x64/vpx_scale_rtcd.h
@@ -13,55 +13,81 @@
 extern "C" {
 #endif
 
-void vp8_horizontal_line_2_1_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_2_1_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_2_1_scale vp8_horizontal_line_2_1_scale_c
 
-void vp8_horizontal_line_5_3_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_3_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_3_scale vp8_horizontal_line_5_3_scale_c
 
-void vp8_horizontal_line_5_4_scale_c(const unsigned char *source, unsigned int source_width, unsigned char *dest, unsigned int dest_width);
+void vp8_horizontal_line_5_4_scale_c(const unsigned char* source,
+                                     unsigned int source_width,
+                                     unsigned char* dest,
+                                     unsigned int dest_width);
 #define vp8_horizontal_line_5_4_scale vp8_horizontal_line_5_4_scale_c
 
-void vp8_vertical_band_2_1_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale vp8_vertical_band_2_1_scale_c
 
-void vp8_vertical_band_2_1_scale_i_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_2_1_scale_i_c(unsigned char* source,
+                                     unsigned int src_pitch,
+                                     unsigned char* dest,
+                                     unsigned int dest_pitch,
+                                     unsigned int dest_width);
 #define vp8_vertical_band_2_1_scale_i vp8_vertical_band_2_1_scale_i_c
 
-void vp8_vertical_band_5_3_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_3_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_3_scale vp8_vertical_band_5_3_scale_c
 
-void vp8_vertical_band_5_4_scale_c(unsigned char *source, unsigned int src_pitch, unsigned char *dest, unsigned int dest_pitch, unsigned int dest_width);
+void vp8_vertical_band_5_4_scale_c(unsigned char* source,
+                                   unsigned int src_pitch,
+                                   unsigned char* dest,
+                                   unsigned int dest_pitch,
+                                   unsigned int dest_width);
 #define vp8_vertical_band_5_4_scale vp8_vertical_band_5_4_scale_c
 
-void vp8_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vp8_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vp8_yv12_copy_frame vp8_yv12_copy_frame_c
 
-void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vp8_yv12_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vp8_yv12_extend_frame_borders vp8_yv12_extend_frame_borders_c
 
-void vpx_extend_frame_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_borders vpx_extend_frame_borders_c
 
-void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config *ybf);
+void vpx_extend_frame_inner_borders_c(struct yv12_buffer_config* ybf);
 #define vpx_extend_frame_inner_borders vpx_extend_frame_inner_borders_c
 
-void vpx_yv12_copy_frame_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_frame_c(const struct yv12_buffer_config* src_ybc,
+                           struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_frame vpx_yv12_copy_frame_c
 
-void vpx_yv12_copy_y_c(const struct yv12_buffer_config *src_ybc, struct yv12_buffer_config *dst_ybc);
+void vpx_yv12_copy_y_c(const struct yv12_buffer_config* src_ybc,
+                       struct yv12_buffer_config* dst_ybc);
 #define vpx_yv12_copy_y vpx_yv12_copy_y_c
 
 void vpx_scale_rtcd(void);
 
 #ifdef RTCD_C
 #include "vpx_ports/x86.h"
-static void setup_rtcd_internal(void)
-{
-    int flags = x86_simd_caps();
+static void setup_rtcd_internal(void) {
+  int flags = x86_simd_caps();
 
-    (void)flags;
-
+  (void)flags;
 }
 #endif
 

tools/metrics/histograms/enums.xml

diff --git a/tools/metrics/histograms/enums.xml b/tools/metrics/histograms/enums.xml
index 72ff3cc..2e9068b 100644
--- a/tools/metrics/histograms/enums.xml
+++ b/tools/metrics/histograms/enums.xml
@@ -11172,6 +11172,7 @@
   <int value="377" label="NoteTakingAppsLockScreenWhitelist"/>
   <int value="378" label="CastReceiverEnabled"/>
   <int value="379" label="CastReceiverName"/>
+  <int value="380" label="DeviceOffHours"/>
 </enum>
 
 <enum name="EnterprisePolicyInvalidations">

tools/metrics/histograms/histograms.xml

diff --git a/tools/metrics/histograms/histograms.xml b/tools/metrics/histograms/histograms.xml
index 4f8db58..8f2bffcc 100644
--- a/tools/metrics/histograms/histograms.xml
+++ b/tools/metrics/histograms/histograms.xml
@@ -27794,6 +27794,14 @@
   <summary>Network channel used for invalidations.</summary>
 </histogram>
 
+<histogram name="IOS.ContentExtension.DisplayCount" units="count">
+  <owner>olivierrobin@chromium.org</owner>
+  <summary>
+    The number of times the Content Extension was displayed since last Chrome
+    foregrounding. Reported when Chrome is put in foregrounded.
+  </summary>
+</histogram>
+
 <histogram name="IOS.MailtoURLRewritten" enum="Boolean">
   <owner>pkl@chromium.org</owner>
   <summary>
@@ -27802,6 +27810,14 @@
   </summary>
 </histogram>
 
+<histogram name="IOS.SearchExtension.DisplayCount" units="count">
+  <owner>olivierrobin@chromium.org</owner>
+  <summary>
+    The number of times the Search Extension was displayed since last Chrome
+    foregrounding. Reported when Chrome is put in foreground.
+  </summary>
+</histogram>
+
 <histogram name="IOS.ShareExtension.ReceivedEntriesCount" units="files">
   <owner>olivierrobin@chromium.org</owner>
   <summary>

tools/perf/benchmarks/benchmark_smoke_unittest.py

diff --git a/tools/perf/benchmarks/benchmark_smoke_unittest.py b/tools/perf/benchmarks/benchmark_smoke_unittest.py
index edbe89a..71cd4889 100644
--- a/tools/perf/benchmarks/benchmark_smoke_unittest.py
+++ b/tools/perf/benchmarks/benchmark_smoke_unittest.py
@@ -47,7 +47,6 @@
   # disable it in tools/perf/benchmarks/*.
   @benchmark_module.Disabled('chromeos')  # crbug.com/351114
   @benchmark_module.Disabled('android')  # crbug.com/641934
-  @benchmark_module.Disabled('all')  # crbug.com/753542
   def BenchmarkSmokeTest(self):
     # Only measure a single page so that this test cycles reasonably quickly.
     benchmark.options['pageset_repeat'] = 1

tools/perf/benchmarks/media.py

diff --git a/tools/perf/benchmarks/media.py b/tools/perf/benchmarks/media.py
index 4bdbcd1..0def70b7 100644
--- a/tools/perf/benchmarks/media.py
+++ b/tools/perf/benchmarks/media.py
@@ -19,6 +19,7 @@
 import page_sets
 
 
+# TODO(rnephew): Revist the re-enabled benchmarks on Wed, Aug 8 2017.
 # See tr.v.Numeric.getSummarizedScalarNumericsWithNames()
 # https://github.com/catapult-project/catapult/blob/master/tracing/tracing/value/numeric.html#L323
 _IGNORED_STATS_RE = re.compile(
@@ -52,7 +53,6 @@
 # android: See media.android.tough_video_cases below
 @benchmark.Owner(emails=['crouleau@chromium.org'],
                  component='Internals>Media')
-@benchmark.Disabled('android')
 class MediaToughVideoCases(perf_benchmark.PerfBenchmark):
   """Obtains media metrics for key user scenarios."""
   test = media.Media
@@ -70,8 +70,7 @@
     return StoryExpectations()
 
 
-@benchmark.Enabled('android')
-@benchmark.Disabled('l', 'android-webview')  # WebView: crbug.com/419689.
+# If any story is failing on svelte, please only disable on svelte.
 @benchmark.Owner(emails=['crouleau@chromium.org', 'videostack-eng@google.com'],
                  component='Internals>Media')
 class MediaAndroidToughVideoCases(perf_benchmark.PerfBenchmark):
@@ -82,10 +81,6 @@
   options = {'story_tag_filter_exclude': 'is_4k,is_50fps'}
 
   @classmethod
-  def ShouldDisable(cls, possible_browser):
-    return cls.IsSvelte(possible_browser)
-
-  @classmethod
   def Name(cls):
     return 'media.android.tough_video_cases'
 
@@ -130,7 +125,6 @@
 # android: See media.android.tough_video_cases below
 @benchmark.Owner(emails=['johnchen@chromium.org', 'crouleau@chromium.org'],
                  component='Internals>Media')
-@benchmark.Disabled('android')
 class MediaToughVideoCasesTBMv2(_MediaTBMv2Benchmark):
   """Obtains media metrics using TBMv2.
   Will eventually replace MediaToughVideoCases class."""
@@ -154,10 +148,9 @@
     return StoryExpectations()
 
 
+# If any story is failing on svelte, please only disable on svelte.
 @benchmark.Owner(emails=['johnchen@chromium.org', 'crouleau@chromium.org'],
                  component='Internals>Media')
-@benchmark.Enabled('android')
-@benchmark.Disabled('l', 'android-webview')  # WebView: crbug.com/419689.
 class MediaAndroidToughVideoCasesTBMv2(_MediaTBMv2Benchmark):
   """Obtains media metrics for key user scenarios on Android using TBMv2.
   Will eventually replace MediaAndroidToughVideoCases class."""
@@ -166,10 +159,6 @@
   options = {'story_tag_filter_exclude': 'is_4k,is_50fps'}
 
   @classmethod
-  def ShouldDisable(cls, possible_browser):
-    return cls.IsSvelte(possible_browser)
-
-  @classmethod
   def Name(cls):
     return 'media.android.tough_video_cases_tbmv2'
 
@@ -215,11 +204,11 @@
   def GetExpectations(self):
     class StoryExpectations(story.expectations.StoryExpectations):
       def SetExpectations(self):
-        pass # Nothing disabled.
+        self.PermanentlyDisableBenchmark(
+            [story.expectations.ALL], 'Code path is old. crbug.com/676345')
     return StoryExpectations()
 
 
-@benchmark.Disabled('android-webview')  # crbug.com/419689
 @benchmark.Owner(emails=['crouleau@chromium.org', 'videostack-eng@google.com'],
                  component='Internals>Media>Source')
 class MediaSourceExtensions(perf_benchmark.PerfBenchmark):

tools/perf/benchmarks/smoothness.py

diff --git a/tools/perf/benchmarks/smoothness.py b/tools/perf/benchmarks/smoothness.py
index f664fd27..0c7924f 100644
--- a/tools/perf/benchmarks/smoothness.py
+++ b/tools/perf/benchmarks/smoothness.py
@@ -415,7 +415,6 @@
     return StoryExpectations()
 
 
-@benchmark.Disabled('all') # http://crbug.com/631015
 @benchmark.Owner(emails=['bokan@chromium.org'])
 class SmoothnessToughPinchZoomCases(_Smoothness):
   """Measures rendering statistics for pinch-zooming in the tough pinch zoom
@@ -453,10 +452,7 @@
     return StoryExpectations()
 
 
-# This benchmark runs only on android by it is disabled on android as well
-# because of http://crbug.com/610021
-# @benchmark.Enabled('android')
-@benchmark.Disabled('all')
+@benchmark.Enabled('android')
 @benchmark.Owner(emails=['ericrk@chromium.org'])
 class SmoothnessGpuRasterizationToughPinchZoomCases(_Smoothness):
   """Measures rendering statistics for pinch-zooming in the tough pinch zoom
@@ -527,7 +523,6 @@
     return StoryExpectations()
 
 
-@benchmark.Disabled('all')  # crbug.com/667489
 @benchmark.Owner(emails=['ericrk@chromium.org'])
 class SmoothnessGpuRasterizationToughScrollingCases(_Smoothness):
   tag = 'gpu_rasterization'
@@ -562,7 +557,6 @@
     return StoryExpectations()
 
 
-@benchmark.Disabled('android')  # http://crbug.com/610015
 @benchmark.Owner(emails=['cblume@chromium.org'])
 class SmoothnessImageDecodingCases(_Smoothness):
   """Measures decoding statistics for jpeg images.
@@ -577,10 +571,6 @@
   def Name(cls):
     return 'smoothness.image_decoding_cases'
 
-  @classmethod
-  def ShouldDisable(cls, possible_browser):
-    return cls.IsSvelte(possible_browser)  # http://crbug.com/563974
-
   def GetExpectations(self):
     class StoryExpectations(story_module.expectations.StoryExpectations):
       def SetExpectations(self):

tools/perf/chrome_telemetry_build/BUILD.gn

diff --git a/tools/perf/chrome_telemetry_build/BUILD.gn b/tools/perf/chrome_telemetry_build/BUILD.gn
index 1ea001b..54a039c 100644
--- a/tools/perf/chrome_telemetry_build/BUILD.gn
+++ b/tools/perf/chrome_telemetry_build/BUILD.gn
@@ -62,7 +62,6 @@
       data += [
         "$root_out_dir/base.dll.pdb",
         "$root_out_dir/blink_platform.dll.pdb",
-        "$root_out_dir/blink_web.dll.pdb",
         "$root_out_dir/content.dll.pdb",
       ]
     } else {

tools/perf/core/perf_data_generator.py

diff --git a/tools/perf/core/perf_data_generator.py b/tools/perf/core/perf_data_generator.py
index f79aabd6..f2e2232 100755
--- a/tools/perf/core/perf_data_generator.py
+++ b/tools/perf/core/perf_data_generator.py
@@ -812,6 +812,7 @@
 
 # Overrides the default 2 hour timeout for swarming tasks.
 BENCHMARK_SWARMING_TIMEOUTS = {
+    'loading.desktop': 14400, # 4 hours (crbug.com/753798)
     'loading.mobile': 16200, # 4.5 hours
     'system_health.memory_mobile': 10800, # 3 hours
     'system_health.memory_desktop': 10800, # 3 hours

ui/app_list/views/app_list_view.cc

diff --git a/ui/app_list/views/app_list_view.cc b/ui/app_list/views/app_list_view.cc
index 1dfeb83..7dd66588 100644
--- a/ui/app_list/views/app_list_view.cc
+++ b/ui/app_list/views/app_list_view.cc
@@ -1130,9 +1130,9 @@
 }
 
 void AppListView::SetBackgroundShieldColor() {
-  // There is a chance when AppListView::OnWallpaperColorsChanged called from
-  // AppListViewDelegate and the app_list_background_shield_ is not initialized.
-  if (!is_fullscreen_app_list_enabled_ && !app_list_background_shield_)
+  // There is a chance when AppListView::OnWallpaperColorsChanged is called from
+  // AppListViewDelegate, the |app_list_background_shield_| is not initialized.
+  if (!is_fullscreen_app_list_enabled_ || !app_list_background_shield_)
     return;
 
   std::vector<SkColor> prominent_colors;

ui/events/blink/input_handler_proxy.cc

diff --git a/ui/events/blink/input_handler_proxy.cc b/ui/events/blink/input_handler_proxy.cc
index a1a68df..9e190b6 100644
--- a/ui/events/blink/input_handler_proxy.cc
+++ b/ui/events/blink/input_handler_proxy.cc
@@ -825,6 +825,7 @@
                               scroll_status.main_thread_scrolling_reasons);
 
   InputHandlerProxy::EventDisposition result = DID_NOT_HANDLE;
+  scroll_sequence_ignored_ = false;
   switch (scroll_status.thread) {
     case cc::InputHandler::SCROLL_ON_IMPL_THREAD:
       TRACE_EVENT_INSTANT0("input",
@@ -924,10 +925,8 @@
     input_handler_->ScrollEnd(&scroll_state);
   }
 
-  if (scroll_sequence_ignored_) {
-    scroll_sequence_ignored_ = false;
+  if (scroll_sequence_ignored_)
     return DROP_EVENT;
-  }
 
   if (!gesture_scroll_on_impl_thread_)
     return DID_NOT_HANDLE;
@@ -942,6 +941,13 @@
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleGestureFlingStart(
     const WebGestureEvent& gesture_event) {
+#ifndef NDEBUG
+  expect_scroll_update_end_ = false;
+#endif
+
+  if (scroll_sequence_ignored_)
+    return DROP_EVENT;
+
   cc::ScrollState scroll_state = CreateScrollStateForGesture(gesture_event);
   cc::InputHandler::ScrollStatus scroll_status;
   scroll_status.main_thread_scrolling_reasons =
@@ -972,10 +978,6 @@
       return DID_NOT_HANDLE;
   }
 
-#ifndef NDEBUG
-  expect_scroll_update_end_ = false;
-#endif
-
   switch (scroll_status.thread) {
     case cc::InputHandler::SCROLL_ON_IMPL_THREAD: {
       if (!touchpad_and_wheel_scroll_latching_enabled_ &&

ui/gfx/native_widget_types.h

diff --git a/ui/gfx/native_widget_types.h b/ui/gfx/native_widget_types.h
index 517bd40..fbe0fef 100644
--- a/ui/gfx/native_widget_types.h
+++ b/ui/gfx/native_widget_types.h
@@ -133,6 +133,12 @@
 typedef ui::ViewAndroid* NativeView;
 typedef ui::WindowAndroid* NativeWindow;
 typedef jobject NativeEvent;
+#elif defined(OS_FUCHSIA)
+// TODO(fuchsia): Update when we have a plan for UI on Fuchsia.
+typedef void* NativeCursor;
+typedef void* NativeView;
+typedef void* NativeWindow;
+typedef void* NativeEvent;
 #else
 #error Unknown build environment.
 #endif
@@ -197,6 +203,10 @@
 #elif defined(USE_OZONE)
 typedef int32_t AcceleratedWidget;
 constexpr AcceleratedWidget kNullAcceleratedWidget = 0;
+#elif defined(OS_FUCHSIA)
+// TODO(fuchsia): Update when we have a plan for UI on Fuchsia.
+typedef void* AcceleratedWidget;
+constexpr AcceleratedWidget kNullAcceleratedWidget = 0;
 #else
 #error unknown platform
 #endif

ui/ozone/demo/surfaceless_gl_renderer.cc

diff --git a/ui/ozone/demo/surfaceless_gl_renderer.cc b/ui/ozone/demo/surfaceless_gl_renderer.cc
index 7930d017..a566563 100644
--- a/ui/ozone/demo/surfaceless_gl_renderer.cc
+++ b/ui/ozone/demo/surfaceless_gl_renderer.cc
@@ -115,6 +115,7 @@
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   }
 
+  disable_primary_plane_ = command_line->HasSwitch("disable-primary-plane");
   PostRenderFrameTask(gfx::SwapResult::SWAP_ACK);
   return true;
 }
@@ -178,9 +179,11 @@
   glClearColor(1 - fraction, 0.0, fraction, 1.0);
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-  surface_->ScheduleOverlayPlane(0, gfx::OVERLAY_TRANSFORM_NONE,
-                                 buffers_[back_buffer_]->image(),
-                                 gfx::Rect(size_), gfx::RectF(0, 0, 1, 1));
+  if (!disable_primary_plane_) {
+    surface_->ScheduleOverlayPlane(0, gfx::OVERLAY_TRANSFORM_NONE,
+                                   buffers_[back_buffer_]->image(),
+                                   gfx::Rect(size_), gfx::RectF(0, 0, 1, 1));
+  }
 
   if (overlay_buffer_) {
     gfx::Rect overlay_rect(overlay_buffer_->size());

ui/ozone/demo/surfaceless_gl_renderer.h

diff --git a/ui/ozone/demo/surfaceless_gl_renderer.h b/ui/ozone/demo/surfaceless_gl_renderer.h
index 5467435..513dc5d3 100644
--- a/ui/ozone/demo/surfaceless_gl_renderer.h
+++ b/ui/ozone/demo/surfaceless_gl_renderer.h
@@ -58,6 +58,7 @@
   std::unique_ptr<BufferWrapper> buffers_[2];
 
   std::unique_ptr<BufferWrapper> overlay_buffer_;
+  bool disable_primary_plane_ = false;
 
   std::unique_ptr<OverlayCandidatesOzone> overlay_checker_;
 

ui/ozone/platform/drm/gpu/crtc_controller.cc

diff --git a/ui/ozone/platform/drm/gpu/crtc_controller.cc b/ui/ozone/platform/drm/gpu/crtc_controller.cc
index 7cd12cb0..ae4f9b02 100644
--- a/ui/ozone/platform/drm/gpu/crtc_controller.cc
+++ b/ui/ozone/platform/drm/gpu/crtc_controller.cc
@@ -81,20 +81,19 @@
   DCHECK(!page_flip_request_.get() || test_only);
   DCHECK(!is_disabled_);
   const OverlayPlane* primary = OverlayPlane::GetPrimaryPlane(overlays);
-  if (!primary) {
-    LOG(ERROR) << "No primary plane to display on crtc " << crtc_;
-    page_flip_request->Signal(gfx::SwapResult::SWAP_ACK);
-    return true;
-  }
-  DCHECK(primary->buffer.get());
-
-  if (primary->buffer->GetSize() != gfx::Size(mode_.hdisplay, mode_.vdisplay)) {
-    VLOG(2) << "Trying to pageflip a buffer with the wrong size. Expected "
-            << mode_.hdisplay << "x" << mode_.vdisplay << " got "
-            << primary->buffer->GetSize().ToString() << " for"
-            << " crtc=" << crtc_ << " connector=" << connector_;
-    page_flip_request->Signal(gfx::SwapResult::SWAP_ACK);
-    return true;
+  if (primary) {
+    DCHECK(primary->buffer.get());
+    // TODO(dcastagna): Get rid of this. Scaling on the primary plane is
+    // supported on all the devices.
+    if (primary->buffer->GetSize() !=
+        gfx::Size(mode_.hdisplay, mode_.vdisplay)) {
+      VLOG(2) << "Trying to pageflip a buffer with the wrong size. Expected "
+              << mode_.hdisplay << "x" << mode_.vdisplay << " got "
+              << primary->buffer->GetSize().ToString() << " for"
+              << " crtc=" << crtc_ << " connector=" << connector_;
+      page_flip_request->Signal(gfx::SwapResult::SWAP_ACK);
+      return true;
+    }
   }
 
   if (!drm_->plane_manager()->AssignOverlayPlanes(plane_list, overlays, crtc_,

ui/ozone/platform/drm/gpu/hardware_display_controller.cc

diff --git a/ui/ozone/platform/drm/gpu/hardware_display_controller.cc b/ui/ozone/platform/drm/gpu/hardware_display_controller.cc
index 43b1a99..cb97347c 100644
--- a/ui/ozone/platform/drm/gpu/hardware_display_controller.cc
+++ b/ui/ozone/platform/drm/gpu/hardware_display_controller.cc
@@ -107,7 +107,7 @@
             [](const OverlayPlane& l, const OverlayPlane& r) {
               return l.z_order < r.z_order;
             });
-  if (pending_planes.front().z_order != 0) {
+  if (pending_planes.front().z_order < 0) {
     std::move(callback).Run(gfx::SwapResult::SWAP_FAILED);
     return false;
   }

ui/ozone/platform/drm/gpu/hardware_display_controller_unittest.cc

diff --git a/ui/ozone/platform/drm/gpu/hardware_display_controller_unittest.cc b/ui/ozone/platform/drm/gpu/hardware_display_controller_unittest.cc
index 0dbd989..615aa37 100644
--- a/ui/ozone/platform/drm/gpu/hardware_display_controller_unittest.cc
+++ b/ui/ozone/platform/drm/gpu/hardware_display_controller_unittest.cc
@@ -400,7 +400,7 @@
   EXPECT_EQ(1, page_flips_);
 }
 
-TEST_F(HardwareDisplayControllerTest, FailPageFlippingDueToNoPrimaryPlane) {
+TEST_F(HardwareDisplayControllerTest, CheckNoPrimaryPlane) {
   ui::OverlayPlane plane1(scoped_refptr<ui::ScanoutBuffer>(
                               new ui::MockScanoutBuffer(kDefaultModeSize)),
                           1, gfx::OVERLAY_TRANSFORM_NONE,
@@ -413,7 +413,7 @@
                          base::Unretained(this)));
 
   drm_->RunCallbacks();
-  EXPECT_EQ(gfx::SwapResult::SWAP_FAILED, last_swap_result_);
+  EXPECT_EQ(gfx::SwapResult::SWAP_ACK, last_swap_result_);
   EXPECT_EQ(1, page_flips_);
 }